POJ 3169 Layout （spfa+差分约束）

题目链接：http://poj.org/problem?id=3169

题目大意：n头牛，按编号1~n从左往右排列，可以多头牛站在同一个点，给出ml行条件，每行三个数a b c表示dis[b]-dis[a]<=c，接下来有md行条件，每行三个数a b c，表示dis[b]-dis[a]>=c。求出出第一头牛和第n头牛的最大可能距离。若不可能把所有牛排成一排即条件有矛盾，则输出“-1”，若第一头牛和第n头牛的距离可以无限大，则输出“-2”。

解题思路：第二道差分约束的题目。根据题目给出的三个约束条件：

　　　　　①dis[B]-dis[A]<=C

　　　　　②dis[B]-dis[A]>=C → dis[A]-dis[B]<=-C

　　　　　③dis[A]-dis[B]<=0

建图，然后同样的，因为要使距离尽可能大，所以if(dis[i]-dis[k]>cost[k][i])   dis[i]=dis[k]+cost[k][i]。

当出现负环，则说明该图矛盾，输出“-1”，当dis[n]==INF说明1和n之间距离可以无穷大，输出“-2”，其他时候输出dis[n]-dis[1]。

代码：

 #include<iostream>
 #include<cstring>
 #include<cstdio>
 #include<algorithm>
 #include<queue>
 using namespace std;
 const int N=1e3+;
 const int INF=0x3f3f3f3f;
 const int MAXN=3e4+;

 struct node{
     int to,w,next;
 }edge[MAXN];

 int n,idx;
 int head[N],dis[N],qcnt[N];
 bool vis[N];

 void init(){
     idx=;
     memset(head,-,sizeof(head));
 }

 void addedge(int u,int v,int w){
     edge[idx].w=w;
     edge[idx].to=v;
     edge[idx].next=head[u];
     head[u]=idx;
     idx++;
 }

 bool spfa(int s) {
     memset(dis,0x3f,sizeof(dis));
     dis[s]=;
     queue<int>q;
     q.push(s);
     while(!q.empty()){
         int k=q.front();
         q.pop();
         vis[k]=false;
         for(int i=head[k];i!=-;i=edge[i].next){
             node t=edge[i];
             if(dis[k]+t.w<dis[t.to]){
                 dis[t.to]=dis[k]+t.w;
                 if(!vis[t.to]){
                     q.push(t.to);
                     qcnt[t.to]++;
                     if(qcnt[t.to]>=n)
                         return false;
                     vis[t.to]=true;
                 }
             }
         }
     }
     return true;
 }

 int main(){
     init();
     int ml,md;
     scanf("%d%d%d",&n,&ml,&md);
     int a,b,c;
     for(int i=;i<=ml;i++){
         scanf("%d%d%d",&a,&b,&c);
         addedge(a,b,c);            //b-a<=c
     }
     for(int i=;i<=md;i++){
         scanf("%d%d%d",&a,&b,&c);
         addedge(b,a,-c);        //b-a>=c → a-b<=-c都改成小于的形式
     }
     for(int i=;i<=n-;i++){
         addedge(i+,i,);        //默认的dis[i+1]-dis[i]>=0
     }
     if(!spfa())
         puts("-1");
     else if(dis[n]==INF)
         puts("-2");
     else
         printf("%d\n",dis[n]-dis[]);
     return ;
 }