P1993 小K的农场 - 差分约束

Posted 2021-01-12 zolrk

看出不等式之后，通过移项套模型
大概不等式模型是这样的：(x_v <= x_u + w_{(u, v)})
(x_v - x_u <= w_{(u, v)})
从减数到被减数连边
长得和最短路的三角形不等式似的
所以求解也围绕着不等式
可以看出(x_v)的最大值就是一条最短路的形式
若最短路不存在（负环），(x_v)的值也不存在
用dfs_spfa判最短路，注意退出递归层的时候让vis[x] = 0
另外注意求最短路时初始化d数组为INF，虽然说判负环初始化为0貌似没啥问题（也可能是这题数据水），但是初始化对于复杂度影响不大。。。

#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>
#include <queue>
using namespace std;
#define debug(x) cerr << #x << "=" << x << endl;
const int MAXN = 10000 + 10;
int n,m,vis[MAXN],cnt[MAXN],last[MAXN],edge_tot,d[MAXN];
struct Edge{
    int u, v, w, to;
    Edge(){}
    Edge(int u, int v, int w, int to) : u(u), v(v), w(w), to(to) {}
}e[MAXN * 2];
inline void add(int u, int v, int w) {
    e[++edge_tot] = Edge(u, v, w, last[u]);
    last[u] = edge_tot; 
}
bool flg;
queue<int> q;

void spfa(int x) {
    vis[x] = 1;
    if(flg) return;
    for(int i=last[x]; i; i=e[i].to) {
        int v = e[i].v, w = e[i].w;
        if(d[v] > d[x] + w) {
            if(vis[v]) {
                flg = true;//在递归层里又被访问一次，并且路径更短，那么是不是可以多走几次这样的路？
                return;
            }
            d[v] = d[x] + w;
            spfa(v);
        }
    }
    vis[x] = 0;
}

int main() {
    scanf("%d%d", &n, &m);
    for(int i=1; i<=m; i++) {
        int cmd, a, b, c;
        scanf("%d", &cmd);
        if(cmd == 1) {
            scanf("%d%d%d", &a, &b, &c);
            add(a, b, -c);
        } else if(cmd == 2) {
            scanf("%d%d%d", &a, &b, &c);
            add(b, a, c);
        } else {
            scanf("%d%d", &a, &b);
            add(a ,b, 0);
            add(b, a, 0);
        }
    }
    memset(d, 0x3f, sizeof(d));
    for(int i=1; i<=n; i++) {   
        d[i] = 0;
        spfa(i);
        if(flg) break;
    }
    if(flg) printf("No");
    else printf("Yes");
    return 0;
}

另外，bfs判负环（复杂度上界为n*m）：

bool SPFA(int s) {
    dist[s] = 0;
    q.push(s);
    vis[s] = 1;
    cnt[s] = 0;
    while(!q.empty()) {
        int x = q.front();
        q.pop();
        vis[x] = 0;
        for(int i=last[x]; i; i=e[i].to) {
            int v = e[i].v;
            int w = e[i].w;
            if(dist[v] > dist[x] + w) {
                dist[v] = dist[x] + w;
                cnt[v] = cnt[x] + 1;
                if(cnt[v] >= n) {
                    return 1;  
                }
                if(!vis[v]) q.push(v), vis[v] = 1;
            }
        }
    }
    return 0;
}