差分约束

很好的讲解：http://www.cppblog.com/menjitianya/archive/2015/11/19/212292.html

差分约束：

一：求最大值，转换成求最短路。

给定不等式 A-B<=C;

步骤如下：

既然是求最短路，肯定要用到过程中最重要的【松弛操作】，即

if(dis[v]>dis[u]+w)   dis[v]=dis[u]+w;

这一步的目的是尽量使dis[v]<=dis[u]+w;

由此我们可把上面的不等式转化成类似的形式，即A<=B+C;（注意此处C可能是负值）

建立一条B到A边权为C的路，然后进行最短路即可。

二：求最小值，转换成求最长路。

基本和第一种相同。

不过是将不等式装换成B>=A-C;（再说一次C是带符号运算的！）

为了松弛操作时 if(dis[B]<dis[A]-C) dis[B]=dis[A]-C; 

上面都是最简单的线性约束的情况。。复杂一些的还不是很理解，等学好了再补。

Layout

 POJ - 3169

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=1010;
const int maxe=20010;
const int inf=0x3f3f3f3f;
int n,m,c;
int u,v,w;
struct edge
{
    int v,w,nex;
}e[maxe];
int head[maxn],ins[maxn],sta[maxn],dis[maxn];
int cnt;

void add(int u,int v,int w)
{
    e[cnt].v=v;
    e[cnt].w=w;
    e[cnt].nex=head[u];
    head[u]=cnt++;
}

int spfa(int s)
{
    for(int i=1;i<=n;i++)
    {
        dis[i]=inf;
        ins[i]=0;
    }
    dis[s]=0;
    ins[s]=1;
    int top=0;
    sta[top++]=s;
    while(top)
    {
        int u=sta[--top];
        for(int i=head[u];i!=-1;i=e[i].nex)
        {
            int v=e[i].v;
            int w=e[i].w;
            if(ins[v]==n) return -1;  //入队>=n次;说明存在负环
            if(dis[v]>dis[u]+w)
            {
                dis[v]=dis[u]+w;
                ins[v]++;
                sta[top++]=v;
            }
        }
    }
    if(dis[n]==inf) return -2;   //说明不可达
    else return dis[n];
}

int main()
{
    while(scanf("%d%d%d",&n,&m,&c)!=EOF)
    {
        memset(head,-1,sizeof head);
        cnt=0;
        for(int i=0;i<m;i++)
        {
            scanf("%d%d%d",&u,&v,&w);  //d[v]-d[u]<=w  ->   d[v]<=d[u]+w  ->   if:  d[v]>d[u]+w
            if(u>v) swap(u,v);
            add(u,v,w);
        }
        for(int i=0;i<c;i++)
        {
            scanf("%d%d%d",&u,&v,&w);   //  d[v]-d[u]>=w  ->  d[u]<=d[v]-w  ->  if: d[u]>d[v]-w
            if(u>v) swap(u,v);
            add(v,u,-w);

        }
        printf("%d
",spfa(1));


    }
    return 0;
}

Candies

 POJ - 3159

#include<cstdio>
#include<cstring>
#include<stack>
using namespace std;
const int maxn=30010;
const int maxe=150010;
const int maxx=0x3f3f3f3f;
int dis[maxn];
int head[maxn];
int ins[maxn];
int cnt=0;

int n,m;
int u,v,w;

stack<int> sta;
struct edge
{
    int v,w,nex;
}e[maxe];

void add(int u,int v,int w)
{
    e[cnt].v=v;
    e[cnt].w=w;
    e[cnt].nex=head[u];
    head[u]=cnt++;
}

int spfa(int s)
{
    for(int i=0;i<=n;i++)
    {
        dis[i]=maxx;
        ins[i]=0;
    }
    dis[1]=0;
    ins[1]=1;
    sta.push(1);
    while(!sta.empty())
    {
        int u=sta.top();
        sta.pop();
        ins[u]=0;  //
        for(int i=head[u];i!=-1;i=e[i].nex)
        {
            int v=e[i].v,w=e[i].w;
            if(dis[v]>dis[u]+w)
            {
                dis[v]=dis[u]+w;
                if(!ins[v])
                {
                    ins[v]=1;
                    sta.push(v);
                }
            }
        }
    }
    return dis[n];
}
int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        cnt=0;
        memset(head,-1,sizeof(head));
        for(int i=0;i<m;i++)
        {
            scanf("%d%d%d",&u,&v,&w);
            add(u,v,w);
        }
        printf("%d
",spfa(1));
    }
}

 

Halum

 UVA - 11478 

#include <bits/stdc++.h>
using namespace std;
const int inf=0x3f3f3f3f;
const int maxv=510;
const int maxe=3000;
#define CLR(m,a) memset(m,a,sizeof(m))

struct Edge
{
    int v,w,nex;
}e[maxe];
int head[maxv];
int cnt=0;
void init()
{
    CLR(head,-1);
    cnt=0;
}
void add(int u,int v,int w)
{
    e[cnt].v=v;
    e[cnt].w=w;
    e[cnt].nex=head[u];
    head[u]=cnt++;
}
int n,m;

int inq[maxv],dis[maxv],deg[maxv];
int bellman()
{
    queue<int> q;
    CLR(dis,inf);
    CLR(inq,0);
    CLR(deg,0);
    for(int i=0;i<n;i++){
        q.push(i); dis[i]=0; inq[i]=1; deg[i]=1;
    }
    while(!q.empty()){
        int u=q.front();
        q.pop();
        inq[u]=0;
        for(int i=head[u];~i;i=e[i].nex){
            int v=e[i].v;
            if(dis[v]>dis[u]+e[i].w){
                dis[v]=dis[u]+e[i].w;
                if(!inq[v]){
                    inq[v]=1;
                    q.push(v);
                    if(++deg[v]>=n) return 1;
                }
            }
        }
    }
    return 0;
}
int check(int x)
{
    int ok=1;
    for(int i=0;i<n;i++){
        for(int j=head[i];~j;j=e[j].nex){
            e[j].w-=x;
        }
    }
    if(bellman()) ok=0;
    for(int i=0;i<n;i++){
        for(int j=head[i];~j;j=e[j].nex){
            e[j].w+=x;
        }
    }
    return ok;
}
int main()
{
    while(scanf("%d%d",&n,&m)!=EOF){
        init();
        int u,v,w;
        int maxw=0;
        for(int i=0;i<m;i++){
            scanf("%d%d%d",&u,&v,&w);
            u--;v--;
            add(u,v,w);
            maxw=max(maxw,w);
        }
        if(check(maxw+1)){
            puts("Infinite");
            continue;
        }
        if(!check(1)){
            puts("No Solution");
            continue;
        }
        int L=2,R=maxw;
        while(L<=R){
            int m=L+(R-L)/2;
            if(check(m)) L=m+1;
            else R=m-1;
        }
        printf("%d
",R);
    }
}