[UVA]11478 二分答案+差分约束

You are given a directed graph G(V; E) with a set of vertices and edges. Each edge (i; j) that connects
some vertex i to vertex j has an integer cost associated with that edge.
De ne the operation Halum(v; d) to operate on a vertex v using an integer d as follows: subtract
d from the cost of all edges that enter v and add d to the cost of every edge that leaves v.
As an example of that operation, consider graph G that has three vertices named (1, 2, 3) and two
edges. Edge (1, 2) has cost -1, and edge (2,3) has cost 1. The operation Halum(2; 3) operates on
edges entering and leaving vertex 2. Thus, edge (1, 2) gets cost -1-(-3)=2 and the edge (2, 3) gets cost
1 + (-3) = -2.
Your goal is to apply the Halum function to a graph, potentially repeatedly, until every edge in the
graph has at least a certain cost that is greater than zero. You have to maximize this cost.
Input
Two space-separated integers per case: V (V 500) and E (E 2700). E lines follow. Each line
represents a directed edge using three space-separated integers (u; v; d). Absolute value of cost can be
at most 10000.
Output
If the problem is solvable, then print the maximum possible value. If there is no such solution print
`No Solution'. If the value can be arbitrary large print `Infinite'
Sample Input
2 1

1 2 10

2 1
1 2 -10
3 3
1 2 4
2 3 2
3 1 5
4 5
2 3 4
4 2 5
3 4 2
3 1 0
1 2 -1
Sample Output
Infinite
Infinite
3

1

第一次做差分约束，碰到了一道不是那么水的题...

题目大意

           就是说你可以进行若干次操作，每次操作将某一点入边权值减少d，出边权值增加d.问在这种情况如何操作使最小的边权最大.

题解

          每一次操作之间互不影响，所以我们没必要去考虑操作次数，只用考虑最终结果.由于要使最小边权最大，很容易想到二分答案（最小最大问题）.
         怎么check？
         我们二分最小边权x.我们设sum[u]为操作在u上的d之和（或加或减，这里的sum则是最终结果）。对于两个点(u,v)，若使(u,v)这条边边权>=x(因为x为最小边权)，那么我们由sum的定义可以知道操作完最终边权应为   w(a,b)+sum[u]-sum[v] .那么他应该>=x.所以式子变换得    w(a,b)-x+sum[u]>=sum[v].(w(a,b)为a，b之间本身的边权).这个式子变换就等价于spfa里的松弛关系，即三角不等式，便可以连边跑spfa了，代码里我建了超级原点的.
         Tips:1.每次check边权减去x要跑完spfa记得加上.
                2.多组数据注意memset和变量赋初值.
                3.那个松弛式子也可以看成sum(b)-sum(a)<=w(a,b)-x(这就是为什么我说边权每次要减去x).
                4.差分约束系统判false是出现负环，即每个点入队超过n次(松弛了所有点还能松弛...必定负环).

          The End.

            

#include<stdio.h>
#include<cstring>
#include<queue>
#define maxn 550
#define clear(a) memset(a,0,sizeof(a))
#define full(a)  memset(dis,120,sizeof(a))
using namespace std;
int h[maxn],dis[maxn],cnt[maxn],num,n,m,lf,rg,x,y,z,ans;
bool vis[maxn];
inline const int read(){
    register int f=1,x=0;
    register char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=(x<<3)+(x<<1)+ch-'0';ch=getchar();}
    return f*x;
}
struct edge{
    int nxt,v,w;
}e[maxn*50];
void add(int u,int v,int w){
    e[++num].v=v,e[num].nxt=h[u],e[num].w=w,h[u]=num;
}
bool spfa(){
    deque<int> q;
    clear(vis),clear(cnt),full(dis);
    dis[0]=0,vis[0]=true,cnt[0]++;
    q.push_front(0);
    while(!q.empty()){
      int u=q.front();q.pop_front();vis[u]=false;
      for(int i=h[u];i;i=e[i].nxt){
          int v=e[i].v;
          if(dis[v]>dis[u]+e[i].w){
             dis[v]=dis[u]+e[i].w;
             if(!vis[v]){
             	if(++cnt[v]>n) return false;
                if(q.empty()||dis[v]<dis[q.front()]) q.push_front(v);
                else q.push_back(v);
                vis[v]=true;
			 }
		  }
	  }
	}
	return true;
}
bool check(int x){
    for(int u=1;u<=n;u++)
     for(int i=h[u];i;i=e[i].nxt)
      e[i].w-=x;
    bool The_Final_Problem=spfa();
    for(int u=1;u<=n;u++)
     for(int i=h[u];i;i=e[i].nxt)
      e[i].w+=x;
    return The_Final_Problem;
}
int main(){
    while(scanf("%d%d",&n,&m)!=EOF){
          clear(h),num=0,lf=1,rg=0;
		  for(int i=1;i<=n;i++) add(0,i,0);
          for(int i=1;i<=m;i++){
              x=read(),y=read(),z=read();
              add(x,y,z);
              if(z>rg) rg=z;
		  }
		  if(check(rg)) {puts("Infinite");continue;}
		  else if(!check(lf)) {puts("No Solution");continue;}
		  while(lf<=rg){
		     int mid=(lf+rg)>>1;
		     if(check(mid)) ans=mid,lf=mid+1;
		     else rg=mid-1;
		  }
		  while(check(ans+1)) ans++;
		  printf("%d\n",ans);
	}
}