差分约束

差分约束系统

在一个差分约束系统(system of difference constraints)中，线性规划矩阵A的每一行包含一个1和一个-1，A的其他所有元素都为0。因此，由Ax≤b给出的约束条件是m个差分约束集合，其中包含n个未知量，对应的线性规划矩阵A为m行n列。每个约束条件为如下形式的简单线性不等式：xj-xi≤bk。其中1≤i,j≤n，1≤k≤m。

例如，考虑这样一个问题，寻找一个5维向量x=(xi)以满足：

 

这一问题等价于找出未知量xi，i=1,2,…,5，满足下列8个差分约束条件：

x1-x2≤0

x1-x5≤-1

x2-x5≤1

x3-x1≤5

x4-x1≤4

x4-x3≤-1

x5-x3≤-3

x5-x4≤-3

    该问题的一个解为x=(-5,-3,0,-1,-4)，另一个解y=(0,2,5,4,1)，这2个解是有联系的：y中的每个元素比x中相应的元素大5。

 
引理：设x=(x1,x2,…,xn)是差分约束系统Ax≤b的一个解，d为任意常数。则x+d=(x1+d,x2+d,…,xn+d)也是该系统Ax≤b的一个解。

http://poj.org/problem?id=3159

给n个人派糖果，给出m组数据，每组数据包含A，B，c  三个数，
意思是A的糖果数比B少的个数不多于c,即B的糖果数 - A的糖果数<= c 。
最后求n 比 1 最多多多少糖果。

算是裸题   v-u《=w  建有向边  u-》v  权值w  若有负环无解  

 //大-小<=c ,有向边(小，大）：c

如果是大于等于的  转化一下  如下

//大-小>=c,小-大<=-c,有向边(大，小):-c

【解题思路】
这是一题典型的差分约束题。不妨将糖果数当作距离，把相差的最大糖果数看成有向边AB的权值，
我们得到 dis[B]-dis[A]<=w(A,B)。看到这里，我们联想到求最短路时的松弛技术，
即if(dis[B]>dis[A]+w(A,B), dis[B]=dis[A]+w(A,B)。
即是满足题中的条件dis[B]-dis[A]<=w(A,B），由于要使dis[B] 最大，
所以这题可以转化为最短路来求。
这题如果用SPFA 算法的话，则需要注意不能用spfa+queue 来求,会TLE ，而是用 spfa + stack

 我用了priority的dij   因为题目保证了有解

#include<cstdio>
#include<queue>
using namespace std;
const int inf=0x3f3f3f3f;
class Dijkstra { ///单源最短路 o(ME*log(MV))
    typedef int typec;///边权的类型
    static const int ME=2e5+10;///边的个数
    static const int MV=3e4+10;///点的个数
    struct Q {
        int id;
        typec w;
        friend bool operator <(const Q &a,const Q &b) {
            return a.w>b.w;
        }
    } now;
    priority_queue<Q> q;
    struct E {
        int v,next;
        typec w;
    } e[ME];
    int n,le,head[MV],u,v,i;
    typec dist[MV],w;
    bool used[MV];
public:
    void init(int tn) {///传入点的个数
        n=tn;
        le=0;
        for(i=0; i<=n; i++) head[i]=-1;
    }
    void add(int u,int v,typec w) {
        e[le].v=v;
        e[le].w=w;
        e[le].next=head[u];
        head[u]=le++;
    }
    void solve(int s) {///传入起点
        for(i=0; i<=n; i++) {
            used[i]=true;
            dist[i]=inf;
        }
        dist[s]=0;
        now.id=s;
        now.w=0;
        while(!q.empty()) q.pop();
        q.push(now);
        while(!q.empty()) {
            now=q.top();
            q.pop();
            u=now.id;
            if(used[u]) {
                used[u]=false;
                for(i=head[u]; ~i; i=e[i].next) {
                    v=e[i].v;
                    w=e[i].w;
                    if(used[v]&&dist[v]>w+dist[u]) {
                        dist[v]=w+dist[u];
                        now.id=v;
                        now.w=dist[v];
                        q.push(now);
                    }
                }
            }
        }
    }
    typec getdist(int id) {
        return dist[id];
    }
} g;

int main(){
    int n,m,u,v,w;
    while(~scanf("%d%d",&n,&m)){
        g.init(n);
        while(m--){
            scanf("%d%d%d",&u,&v,&w);
            g.add(u,v,w);
        }
        g.solve(1);
        printf("%d
",g.getdist(n));
    }
    return 0;
}

poj http://poj.org/problem?id=3169

有》=也有《=，  大于等于的移项一下，还是跟小于等于一样的建边，有负环是无解，最短路是inf是任意解，有最短路就是唯一解

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<stack>
#define mt(a,b) memset(a,b,sizeof(a))
using namespace std;
const int inf=0x3f3f3f3f;
class Spfa { ///单源最短路o(k*ME)k~=2
    typedef int typec;///边权的类型
    static const int ME=2e4+10;///边的个数
    static const int MV=1e3+10;///点的个数
    struct E {
        int v,next;
        typec w;
    } e[ME];
    int n,le,head[MV],inque[MV],i,u,v;
    typec dist[MV];
    bool used[MV];
    queue<int> q;
public:
    void init(int tn) { ///传入点的个数
        n=tn;
        le=0;
        for(i=0; i<=n; i++) head[i]=-1;
    }
    void add(int u,int v,typec w) {
        e[le].v=v;
        e[le].w=w;
        e[le].next=head[u];
        head[u]=le++;
    }
    bool solve(int s) { ///传入起点,存在负环返回false
        for(i=0; i<=n; i++) {
            dist[i]=inf;
            used[i]=true;
            inque[i]=0;
        }
        used[s]=false;
        dist[s]=0;
        inque[s]++;
        while(!q.empty()) q.pop();
        q.push(s);
        while(!q.empty()) {
            u=q.front();
            q.pop();
            used[u]=true;
            for(i=head[u]; ~i; i=e[i].next) {
                v=e[i].v;
                if(dist[v]>dist[u]+e[i].w) {
                    dist[v]=dist[u]+e[i].w;
                    if(used[v]) {
                        used[v]=false;
                        q.push(v);
                        inque[v]++;
                        if(inque[v]>n) return false;
                    }
                }
            }
        }
        return true;
    }
    typec getdist(int id) {
        return dist[id];
    }
} g;
int main() {
    int n;
    int ML,MD;
    int a,b,c;
    while(~scanf("%d%d%d",&n,&ML,&MD)) {
        g.init(n);
        while(ML--) {
            scanf("%d%d%d",&a,&b,&c);
            if(a>b)swap(a,b);//注意加边顺序
            g.add(a,b,c);
            //大-小<=c ,有向边(小，大）：c
        }
        while(MD--) {
            scanf("%d%d%d",&a,&b,&c);
            if(a<b)swap(a,b);
            g.add(a,b,-c);
            //大-小>=c,小-大<=-c,有向边(大，小):-c
        }
        if(!g.solve(1)) printf("-1
");//无解
        else if(g.getdist(n)==inf) printf("-2
");
        else printf("%d
",g.getdist(n));
    }
    return 0;
}