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;
}