HAOI2015PG图

P1857 - 【HAOI2015】PG图

Description

背景
LDN不知道为什么特别喜欢PG，也许是某种原因吧……
有一天，他发明了一个游戏“PG图”。
问题描述

给定一个有向图，每条边都有一个权值。
每次你可以选择一个节点u和一个整数d，把所有以u为终点的边的权值减小d，把所有以u为起点的边的权值加上d。最后要让所有边的权值的最小值为正且尽量大。

Input

输入包含若干组数据。
每组数据第一行为两个整数n和m(n<=500,m<=2700)，表示点和边的个数。
以下m行，每行包括3个整数u,v,w，表示u -> v有一条边权为w的边。(1<= u,v<= n, -10000<= w<= 10000)

Output

对于每组数据，输出边权最小值的最大值；
如果无法让所有边权都大于0，输出“No Solution”；
如果边权最小值可以无限大，输出“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

Hint

数据范围与约定

对于30%的数据:2<= n<= 10,1<= m<= 100
对于60%的数据:2<= n<= 100,1<= m<=1000
对于100%的数据:2<= n<= 500,1<= m<=2700

Source

图论 ， 差分约束

 

通过设每个点的ｄ值为未知数，由于是最小值最大，所以可以用二分，写出式子(a -> b) 

W+sum(a)-sum(b)>=mid ，sum(b)-sum(a)<=W-mid；因此就可以用差分约束来写；

想一下，如果ｍｉｄ可行，那么答案上移，不行，下移，判断行不行，也就是ｓｐｆａ能否跑出来，就是看是否存在负权环，可以用递归版的ｓｐｆａ :

bool spfa(int x) {
    vis[x]=1;
    for(int i=head[x];i;i=e[i].net) {
        int to=e[i].to;
        if(dis[to]>dis[x]+e[i].w) {
            if(vis[to]) return 1;
            dis[to]=dis[x]+e[i].w;
            if(spfa(to)) return 1;
        }
    }
    return vis[x]=0;
}

　　

如果max(r+1)都可以，那么解就是正无穷；１不行，那么无解；

收获　： 首先想到的一定是二分答案,所以不要想d值怎么确定,最后的答案是多少,先设出来,得到一个式子(a -> b) W+sum(a)-sum(b)>=mid ;就很显然用差分约束了;

一定要学会分析,不要急着确定每个d,先列式子,一般是差分约束;

/* QYP kuai wo dai ma*/
#include<algorithm>
#include<iostream>
#include<iomanip>
#include<cstring>
#include<cstdlib>
#include<cstdio>
#include<queue>
#include<ctime>
#include<cmath>
#include<stack>
#include<map>
#include<set>
#define rep(i,a,b) for(register int i=a;i<=b;i++)
#define ll long long
#define re register
using namespace std;
const int N=510,M=2710;
struct Edge{
    int to,net,w;
}e[M];
int head[N],n,m,num_e;
int dis[N];
inline int gi() {
    re int res=0,f=1;
    char ch=getchar();
    while((ch<'0'||ch>'9')&&(ch!='-')) ch=getchar();
    if(ch=='-') ch=getchar(),f=-1;
    while(ch>='0'&&ch<='9') res=res*10+ch-'0',ch=getchar();
    return res*f;
}
inline void add(int x,int y,int w) {
    e[++num_e].to=y,e[num_e].w=w,e[num_e].net=head[x],head[x]=num_e;
}
bool vis[N];
bool spfa(int x) {
    vis[x]=1;
    for(int i=head[x];i;i=e[i].net) {
        int to=e[i].to;
        if(dis[to]>dis[x]+e[i].w) {
            if(vis[to]) return 1;
            dis[to]=dis[x]+e[i].w;
            if(spfa(to)) return 1;
        }
    }
    return vis[x]=0;
}
inline bool check(int x) {
    rep(u,1,n)
        for(int i=head[u];i;i=e[i].net) e[i].w-=x;
    bool flag=1;
    rep(i,1,n) {
        memset(dis,0,sizeof(dis));
        memset(vis,0,sizeof(vis));
        if(spfa(i)) {flag=0;break;}
    }
    rep(u,1,n)
        for(int i=head[u];i;i=e[i].net) e[i].w+=x;
    return flag;
}
int main() {
    freopen("pg.in","r",stdin);
    freopen("pg.out","w",stdout);
    while(scanf("%d%d",&n,&m)!=EOF) {
        memset(head,0,sizeof(head)),num_e=0;
        int l=0,r;
        rep(i,1,m) {
            re int u=gi(),v=gi(),w=gi();
            add(u,v,w);
            r=max(w,r);
        }
        if(!check(1)) {puts("No Solution");continue;}
        else if(check(r+1)) {puts("Infinite");continue;}
        re int mid=0;
        while(l<=r) {
            mid=(l+r)>>1;
            if(check(mid)) l=mid+1;
            else r=mid-1;
        }
        printf("%d
",r);
    }
    return 0;
}