UVA 11478 Halum（二分 + 差分约束）

题目：http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=2473

题目大意：给你一个 n 个点 m 条有向边的图。有一种操作是：选定一个点 v 和一个整数 d ，把以 v 为终点的边权值减小 d ，把以 v 为起点的边权值都增加 d 。你要使所有边权值的最小值尽可能大，并且它要是 > 0 的（注意是 greater than 0 ，不是 >= 0），输出这个值。如果不存在就输出“No Solution”，如果这个值可以无限大，就输出“Infinite”。

解题思路：乍一看这道题目很复杂，无从下手，当我们无法算出这个值是多少的时候，有一种方法可以简化题目：二分答案！（题目中也有最小的值最大的字眼，我竟然没想到。。 = =）我们二分出一个值，要看这个值行不行。假设这个值是 x ，那么他就是最小边权。我们看题目，发现对同一个点的这种操作是可以合并的，假设 a 到 b 一条边，sum( i ) 是对 i 这个点的操作数值和，那么这条边的权值就变为了 w（a，b）+ sum（a）- sum（b），谈后他要大于等于 x 。可就是w（a，b）+ sum（a）- sum（b）>= x，即 sum（b）- sum（a）<= w（a，b）-x，不等式右边，是一个已知常数。对于所有的点都有这个不等式，也就是我们得到了了一个不等式组。然后就是差分约束了，判断是否有解，即是否有负环即可。

然后还有两个特判要做，假设输入边权的最大值是max_c，那么如果我们把所有 边权都 - （max_c+1），那么所有边权都为 负了，如果这个时候还没有负环，就肯定不会有负环了，所以就是无穷大了。另外我们它要 >0，那么我们就另 x = 1，如果这个时候还有负环，那么就肯定是无解。这里我顺便提一句，书上估计是写错了，写的是非负，为什么那么多人博客上写的也是非负，然后后面判断是否无解用的是 1。我就是因为没直接看题目，用的是 0 ，然后 WA 几次，去搜博客才发现这个问题，当时我就很不解，还好有一个人提到了这个地方，才去看了边英文原题。。

另外，差分约束判负环可以不用超级源，因为 自己创的源点 s 是连到了所有点，所以只要像做最短路一样，把 s 一个压倒队列里就行了，这样应该回比超级源快点。

好吧，无论怎么样，这是鄙人的第一道差分约束，基本上是理解了一点。如果各位对差分约束不懂的话，可以看我转的那篇文章：传送门

代码如下：

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

const int INF = 0x0fffffff;

const int MAXN = 555;
const int MAXM = 2777+MAXN;

struct Edge
{
    int s,t,next,val;
} edge[MAXM];

int head[MAXN],tot;

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

void add_edge(int s,int t,int val)
{
    edge[tot].s = s;
    edge[tot].t = t;
    edge[tot].val = val;
    edge[tot].next = head[s];
    head[s] = tot++;
}

int inq[MAXN],cnt[MAXN],d[MAXN];

int negative_cycle(int n)
{
    queue<int>q;
    memset(inq,0,sizeof(inq));
    memset(cnt,0,sizeof(cnt));
    for(int i = 0;i <= n;i++)
    {
        d[i] = INF;
        inq[i] = 1;
        q.push(i);
    }
    while(!q.empty())
    {
        int cur = q.front();
        q.pop();
        inq[cur] = 0;
        for(int i = head[cur];i != -1;i = edge[i].next)
        {
            int next_id = edge[i].t;
            int tmp = d[cur]+edge[i].val;
            if(d[next_id] > tmp)
            {
                d[next_id] = tmp;
                if(!inq[next_id])
                {
                    inq[next_id] = 1;
                    q.push(next_id);
                    if(++cnt[next_id] > (n+1)) return 1;
                }
            }
        }
    }
    return 0;
}

int check(int mid,int n)
{
    for(int i = 0;i < tot;i++)
        if(edge[i].s != 0)
            edge[i].val -= mid;
    int ok = negative_cycle(n);
    for(int i = 0;i < tot;i++)
        if(edge[i].s != 0)
            edge[i].val += mid;
    return ok;
}

int main()
{
    int n,m;
    while(~scanf("%d%d",&n,&m))
    {
        init();
        int max_c = -INF;
        while(m--)
        {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            add_edge(a,b,c);
            max_c = max(max_c,c);
        }
        for(int i = 1;i <= n;i++)
            add_edge(0,i,0);
        if(!check(max_c+1,n))
        {
            puts("Infinite");
            continue;
        }
        if(check(1,n))
        {
            puts("No Solution");
            continue;
        }
        int l = 0,r = max_c;
        int ans;
        while(l <= r)
        {
            int mid = (l+r)>>1;
            if(!check(mid,n))
            {
                ans = mid;
                l = mid+1;
            }
            else r = mid-1;
        }
        printf("%d\n",ans);
    }
    return 0;
}