ShortestPath:Layout(POJ 3169)（差分约束的应用）

　　　　　　　　　     　　　　　　　

　　　　　　　　　　　　　　　         布局

　　题目大意：有N头牛，编号1-N，按编号排成一排准备吃东西，有些牛的关系比较好，所以希望他们不超过一定的距离，也有一些牛的关系很不好，所以希望彼此之间要满足某个关系，牛可以挤在同一个位置上，现在给出N个牛的信息，问你能否实现一种排列方案，使得d[1]到d[N]最大？如果不存在输出-1，无限大输出-2

　　这一题看上去挺难的，但是如果你知道差分约束原理，这一题似乎还是挺简单的。

　　差分约束的原理是：存在任意线性方程，满足d[A]+c>=d[B]，就可以表示为图的最短路形式，方程可以表示为A->B，权值为c的边，最后任意点之间距离之差的最大值，即为两点之间的最短距离。

　　在最短路的算法中，恒有d[u]+w>=d[s](s是源点，w是权值，u是除了s的任意点)，则d[u]-d[s]的最大值即为s-u的最短路经长。

　　回到题目上来，那么这一题事实上蕴含了三个线性方程：

　　　　1.d[i+1]>=d[i]（按照编号排序）

　　　　2.d[BL]-d[AL]<=DL->->->d[AL]+DL>=d[BL]

　　　　3.d[BD]-D[AD]>=DD->->->d[BD]-DD>=d[AD]

　　　　则我们只用把这些边表示出来算最短路径就可以了，这一题有负值边，用Bellman_Ford或者SPFA就可以了

　　

Bellman_Ford:

 #include <iostream>
 #include <functional>
 #include <algorithm>
 #define MAX 0x7f7f7f7f
 
 using namespace std;
 
 typedef int Positon;
 typedef struct least_
 {
     Positon A;
     Positon B;
     int cost;
 }Relation;
 
 static Relation L_Set[],M_Set[];
 static int dist[];
 
 void Bellman_Ford(const int, const int, const int);
 
 int main(void)
 {
     int cows_sum, ML, MD;
     while (~scanf("%d%d%d", &cows_sum, &ML, &MD))
     {
         for (int i = ; i < ML; i++)
             scanf("%d%d%d", &L_Set[i].A, &L_Set[i].B, &L_Set[i].cost);
         for (int i = ; i < MD; i++)
             scanf("%d%d%d", &M_Set[i].A, &M_Set[i].B, &M_Set[i].cost);
         Bellman_Ford(cows_sum, ML, MD);
     }
     return ;
 }
 
 void Bellman_Ford(const int cows_sum, const int ML, const int MD)
 {
     memset(dist, 0x7f, sizeof(dist));
     dist[] = ;//到自己肯定是最短的
 
     for (int i = ; i <= cows_sum; i++)
     {
         for (int i = ; i +  <= cows_sum; i++)
             if (dist[i + ] < MAX)//差分约束方程d[i+1]>=d[i]
                 dist[i] = min(dist[i], dist[i + ]);
         for (int i = ; i < ML; i++)//差分约束方程d[AL]+DL>=d[BL]
             if (dist[L_Set[i].A] < MAX)
                 dist[L_Set[i].B] = min(dist[L_Set[i].B], dist[L_Set[i].A] + L_Set[i].cost);
         for (int i = ; i < MD; i++)//差分约束方程d[BD]-DD>=d[AD]
             if (dist[M_Set[i].B] < MAX)
                 dist[M_Set[i].A] = min(dist[M_Set[i].A], dist[M_Set[i].B] - M_Set[i].cost);
     }
 
     int ans = dist[cows_sum];
     if (dist[] < )
         printf("-1\n");
     else if (dist[cows_sum] == MAX)
         printf("-2\n");
     else printf("%d\n", ans);
 }

SPFA:

 #include <iostream>
 #include <functional>
 #include <algorithm>
 #include <queue>
 #define MAX 0x7f7f7f7f
 
 using namespace std;
 
 typedef int Position;
 typedef struct least_
 {
     int next;
     Position to;
     int cost;
 }Edge_Set;
 
 static Edge_Set edge[];//存边
 static Position Head[];
 static int dist[];
 static int out[];//记录出去多少次
 static bool used[];//记录是否在队内
 
 void SPFA(const int, const int);
 
 int main(void)
 {
     int cows_sum, ML, MD, i, cost, edge_sum;
     Position from, to;
     while (~scanf("%d%d%d", &cows_sum, &ML, &MD))
     {
         memset(Head, -, sizeof(Head)); memset(dist, 0x7f, sizeof(dist)); memset(used, , sizeof(used)); memset(out, , sizeof(out));
         edge_sum = ;
         //读入邻接表
         for (i = ; i < ML; i++)//d[BL]-d[AL]<=DL->->->d[AL]+DL>=d[BL]
         {
             scanf("%d%d%d", &from, &to, &cost);//因为编号是有序的，所以只用储存单向边就可以了
             edge[edge_sum].next = Head[from]; edge[edge_sum].to = to; edge[edge_sum].cost = cost;
             Head[from] = edge_sum++;
         }
         for (i = ; i < MD; i++)//d[BL]-d[AL]>=DL->->->d[BD]-DD>=d[AD]
         {
             scanf("%d%d%d", &from, &to, &cost);
             edge[edge_sum].next = Head[to]; edge[edge_sum].to = from; edge[edge_sum].cost = -cost;
             Head[to] = edge_sum++;
         }
         for (i = ; i +  <= cows_sum; i++)//d[i+1]+0>=d[i]
         {
             edge[edge_sum].next = Head[i + ]; edge[edge_sum].to = i; edge[edge_sum].cost = ;
             Head[i + ] = edge_sum++;
         }
         SPFA(cows_sum, edge_sum);
     }
     return ;
 }
 
 void SPFA(const int cows_sum, const int edge_sum)//这次用STL玩玩
 {
     Position out_pos, to;
     queue<Position>que;
     que.push(); dist[] = ; used[] = ;
 
     while (!que.empty())
     {
         out_pos = que.front(); que.pop();
         used[out_pos] = ;//出队了就标记为0
         out[out_pos]++;
         if (out[out_pos] > cows_sum)
         {
             printf("-1\n");
             return;
         }
         for (int k = Head[out_pos]; k != -; k = edge[k].next)
         {
             to = edge[k].to;
             if (dist[to] > dist[out_pos] + edge[k].cost)
             {
                 dist[to] = dist[out_pos] + edge[k].cost;
                 if (!used[to])
                 {
                     used[to] = ;
                     que.push(to);
                 }
             }
         }
     }
     if (dist[cows_sum] == MAX)
         printf("-2\n");
     else
         printf("%d\n", dist[cows_sum]);
 }