世界真的很大
圖論的演算法是個神奇東西
上次做了這道題就深有感觸了
差分約束也是個差不多的道理，spfa
先看下題吧：
description：

給定一個有向圖，邊有權值，每次操作指定一個點u，一個值d，使所有u的出邊+d，所有入邊-d。問經過數次操作後，最小正邊權最大為多少。如可以無限大就輸出Infinite，如不能為正就輸出No Solution

input

多組資料，輸入到EOF
每組資料第一行包含2個整數n（點），m（邊）
接下來m行每行包含3個整數u，v，w
表示u到v有一條邊權為w的邊

output

每組資料一個輸出表示答案

要求輸出最小的最大，自然想到二分答案
每次二分一個權值val，check能否找到一個方案使所有邊的權值大於val
考慮任意一個點，他的每條入邊和每條出邊的增加（減少）的量肯定是相同的，設為sumi
考慮一條邊（a，b），其操作之後的權值為w（a，b）+suma-sumb ，權值是大於val的，所以：
w（a，b）+suma-sumb > val
移相之後得到：
sumb-suma <= w(a,b)-val
sumb <= w(a,b)-val + suma
這就是差分約束的典型等式了
考慮SPFA中處理的等式
dis[v]< w(u,v) + dis[u]
不是有點相似嗎，這裡w(a,b)-val和w(u,v)都是一個固定的常量，像這樣的這一串式子就可以用像SPFA的方法處理它，如果SPFA能跑出來就說明跑出來了一組可行解，suma就是a點的dis值
如果跑不出來，說明有負環，說明找不到一組可行解
那對於sumb <= w(a,b)-val + suma
我們就連一條a到b，權值為w(a,b)-val的邊，SPFA需要一個源點，因為是單源最短路嘛，所以我們就加一個無關緊要的源點S，使其與所有點連邊，邊權為0
題目規定了上界，所以只要判一下val為最上界是否滿足有解，如果是，就輸出Infinite
題目規定為正數，所以判一下下界1，如果都不行，無解的話就輸出No Solution
完整程式碼：

#include<stdio.h>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;

const int INF=0x3f3f3f3f;

struct edge
{
    int v,last,w;
}ed[100010];

queue <int> state;

int head[100010],dis[100010],se[100010],book[100010];
int n,m,ans,num=0,S=0,big=0;

void init()
{
    num=0
 
,ans=0,S=0,big=0;
    memset(head,0,sizeof(head));
}

void add(int u,int v,int w)
{
    num++;
    ed[num].v=v;
    ed[num].w=w;
    ed[num].last=head[u];
    head[u]=num;
}

bool SPFA()
{
    memset(book,0,sizeof(book));
    memset(dis,0x3f3f3f3f,sizeof(dis));
    memset(se,0,sizeof(se));
    while(!state.empty()) state.pop();
    state.push(S);
    se[S]=1
 
,dis[S]=0,book[S]=1;
    while(!state.empty())
    {
        int u=state.front();
        se[u]=0;state.pop();
        for(int i=head[u];i;i=ed[i].last)
        {
            int v=ed[i].v;
            if(dis[v]>dis[u]+ed[i].w)
            {
                dis[v]=dis[u]+ed[i].w;
                if(!se[v])
                {
                    se[v]=1;
                    state.push(v);
                    book[v]++;
                    if(book[v]>n+1) return 0;                   
                }
            }
        }
    }
    return 1;
}

bool check(int val)
{
    bool flag;
    for(int i=1;i<=num;i++)
        ed[i].w-=val;
    flag=SPFA();
    for(int i=1;i<=num;i++)
        ed[i].w+=val;
    return flag;
}

int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        init();
        for(int i=1;i<=m;i++)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            add(u,v,w);
            big=max(big,w);
        }
        for(int i=1;i<=n;i++)
            add(S,i,0);
        if(check(big+1))
        {
            printf("Infinite\n");
            continue ;
        }
        else if(!check(1))
        {
            printf("No Solution\n"); 
            continue ;
        }
        int lf=1,rg=big;
        while(lf<=rg)
        {
            int mid=(lf+rg)>>1;
            if(check(mid))
            {
                ans=mid;
                lf=mid+1;
            }
            else rg=mid-1;
        }       
        printf("%d\n",ans);
    }
}
/*
Whoso pulleth out this sword from this stone and anvil is duly born King of all England
*/

嗯，就是這樣