HDU 3666 THE MATRIX PROBLEM （差分约束+栈优化spfa判负环）

最新推荐文章于 2021-05-13 16:50:57 发布

原创最新推荐文章于 2021-05-13 16:50:57 发布 · 247 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#差分约束 #栈优化spfa

差分约束专栏收录该内容

7 篇文章

订阅专栏

本文介绍了一种解决矩阵元素运算约束问题的方法，利用差分约束和栈优化的SPFA算法进行求解。核心在于将乘除运算转换为加减运算，并通过DFS模拟避免负环检测。适用于矩阵元素需满足特定范围的场景。

题意：给出一个N∗M的矩阵C，要求构造两个序列a1,a2,…,an和b1,b2,…,bm, 矩阵的第i行元素乘上 ai，矩阵的第j列元素除以bj，最终矩阵的每个元素Cij∈[L,U]。若可以构造成功，则输出YES，否则输出NO。

题解：差分约束+栈优化spfa
可得约束方程： $L < = c * a i / b j < = U$

习惯最长路，于是可以转换为：
$a i / b j > = L / c$ 和 $- a i / b j > = - U / c$

两边取log就可以转换为正常的加减了。

然后这题直接bfs判负环即>n+m会t，看到取根号的，但不知道如何证明，其实可以用dfs判负环，即一直跑这个环，这样效率会很高，我们用栈模拟dfs的过程即可。

注意double。

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<algorithm>
#include<queue>
#include<stack>
#include<cmath>
#include<vector>
#include<fstream>
#include<set>
#include<map>
#include<sstream>
#include<iomanip>
#define ll long long
#define pii pair<int, int>
using namespace std;
const int maxn = 2e5 + 5;
int n, m, l, u, a;
struct node {
    int v, nxt;
    double w;
}edge[maxn << 2];
int vis[maxn], head[maxn], mark[maxn], k, s;
double d[maxn];
void add(int u, int v, double w) {
    edge[++k].nxt = head[u];
    edge[k].v = v;
    edge[k].w = w;
    head[u] = k;
}
//bool spfa() {
//    for (int i = 1; i <= n + m; i++) {
//        vis[i] = mark[i] = 0;
//        d[i] = -0x3f3f3f3f;  //最长路版本
//    }
//    queue<int>q;
//    q.push(s);
//    mark[s] = vis[s] = 1;
//    d[s] = 0;
//    while (!q.empty()) {
//        int u = q.front(); q.pop();
//        vis[u] = 0;
//        for (int i = head[u]; i; i = edge[i].nxt) {
//            int v = edge[i].v;
//            double w = edge[i].w;
//            if (d[v] < d[u] + w) {
//                d[v] = d[u] + w;
//                if (vis[v]) continue;
//                vis[v] = 1;
//                if(++mark[v] > sqrt(n + m)) return false;  //负环 n+1以上才有负环
//                q.push(v);
//            }
//        }
//    }
//    return true;
//}
int q[maxn];
bool spfa() {
    for (int i = 1; i <= n + m; i++) {
        d[i] = -0x3f3f3f3f; 
        vis[i] = mark[i] = 0;
    }
    mark[s] = vis[s] = 1;
    d[s] = 0;
    int ed = 0;
    //q[++ed] = s;
    stack<int> q;
    q.push(s);
    while (q.size()) {
        //int u = q[ed--];
        int u = q.top();
        q.pop();
        vis[u] = 0;
        for (int i = head[u]; i; i = edge[i].nxt) {
            int v = edge[i].v;
            double w = edge[i].w;
            if (d[v] < d[u] + w) {
                d[v] = d[u] + w;
                if (vis[v]) continue;
                vis[v] = 1;
                if (++mark[v] > n + m) return false;
                //q[++ed] = v;
                q.push(v);
            }
        }
    }
    return true;
}
int main() {
	while (~scanf("%d%d%d%d", &n, &m, &l, &u)) {
        k = 0;
        memset(head, 0, sizeof(head));
		for (int i = 1; i <= n; i++) {
			for (int j = 1; j <= m; j++) {
				scanf("%d", &a);
                add(n + j, i, log(1.0 * l / a));
                add(i, j + n, -log(1.0 * u / a));
			}
		}
        s = 1;
        if (spfa()) puts("YES");
        else puts("NO");
	}
	return 0;
}