UVA - 11478 Halum(差分约束系统)

题目大意：有一种操作(u,c)，表示所有以u为终点的边的权值减去c，所有以u为起点的边权值加上c
最后要求所有的边的权值非负且尽量大

解题思路：最小且最大，二分，枚举边的最小权值，然后看是否符合
对于给出的所有有向线段(u,v,val)
所有对u和v的操作才会影响到这条边，对其他点的操作并不会影响到，所以可以将边分开出来讨论
假设对u的操作为d[u]，对v的操作为d[v]，那么这条边的权值就变成了
d[u] - d[v] + val
假设枚举的边权值为w，那么这条边就要满足
d[u] - d[v] + val >= w
转换一下得d[v] <= val - w + d[u]
这样就形成了一个差分约束系统了
有两个要特判的地方，一个是可以累加到无限大的，一个是不符合条件
特判的话就用1和最大权值加1去特判

这题有一个让我很郁闷的地方，就是在SPFA的时候，如果vis设置为true时竟然超时了。。。
然而正规写法确实是要将之设置为true，因为该点被放入队列了
去看了下别人的题解，发现一个神奇的地方，他判断负环的时，如果入队列的次数大于(int)sqrt(n + 1) + 1就判断是负环了。。。
并不知道为什么

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
using namespace std;

#define N 510
#define M 4000
#define S 260010
#define source 505
#define INF 0x3f3f3f3f

struct Edge{
    int to, dist, next;
}E[M];

int head[N], d[N], cnt[N], q[S];
int n, m, tot, Max;
bool vis[N];

void AddEdge(int from, int to, int dist) {
    E[tot].to = to;
    E[tot].dist = dist;
    E[tot].next = head[from];
    head[from] = tot++;
}

void init() {
    memset(head, -1, sizeof(head));
    tot = 0;
    Max = -INF;

    int u, v, d;
    for (int i = 0; i < m; i++) {
        scanf("%d%d%d", &u, &v, &d);
        AddEdge(u, v, d);
        if (Max < d)
            Max = d;
    }
}

bool SPFA(int mid) {

    int front = 0, rear = 0;
    for (int i = 1; i <= n; i++) {
        q[rear++] = i;
        cnt[i] = d[i] = 0;
        vis[i] = false;
    }

    while (front != rear) {
        int u = q[front++];
        vis[u] = false;

        for (int i = head[u]; i != -1; i = E[i].next) {
            int v = E[i].to;
            if(d[v] > d[u] + E[i].dist - mid) {
                d[v] = d[u] + E[i].dist - mid;
                if (!vis[v]) {
                    vis[v] = true;
                    if (++cnt[v] > n)
                        return true;
                    q[rear++] = v;
                }
            }
        }
    }
    return false;
}

void solve() {

    if (!SPFA(Max + 1)) {
        printf("Infinite\n");
        return ;
    }

    if (SPFA(1)) {
        printf("No Solution\n");
        return ;
    }

    int l = 0, r = Max + 1;
    while (l < r) {
        int mid = (l + r) / 2;
        if (!SPFA(mid)) 
            l = mid + 1;
        else
            r = mid;
    }
    printf("%d\n", r - 1);
}

int main() {
    while (scanf("%d%d", &n, &m) != EOF) {
        init();
        solve();
    }
    return 0;
}