POJ 3169 Layout (差分约束)

题意：给定一些母牛，要求一个排列，有的母牛距离不能超过w，有的距离不能小于w，问你第一个和第n个最远距离是多少。

析：以前只是听说过个算法，从来没用过，差分约束。

对于第 i 个母牛和第 i+1 个，D[i] - D[i+1] <= 0,  D[j] -D[i ]<= k, D[i] - D[j] <= - k,那么这个题就可以用差分约束来求这个不等式组了。

1.对于差分不等式，a - b <= c ，建一条 b 到 a 的权值为 c 的边，求的是最短路，得到的是最大值（本题求的就是最大值），对于不等式 a - b >= c ，建一条 b 到 a 的权值为 c 的边，求的是最长路，得到的是最小值。

2.如果检测到负环，那么无解。

3.如果d[n]没有更新，那么可以是任意解。

代码如下：

#include <cstdio>
#include <string>
#include <cstdlib>
#include <cmath>
#include <iostream>
#include <cstring>
#include <set>
#include <queue>
#include <algorithm>
#include <vector>
#include <map>
using namespace std ;
typedef long long LL;
typedef pair<int, int> P;
const int INF = 0x3f3f3f3f;
const double inf = 0x3f3f3f3f3f3f3f;
const double eps = 1e-8;
const int maxn = 10000 + 5;
const int dr[] = {0, 0, -1, 1};
const int dc[] = {-1, 1, 0, 0};
int n, m;
struct node{
    int to, w, next, from;
};
int cnt = 0;
node G[maxn<<1];
int d[maxn];

void add(int u, int v, int w){
    G[cnt].w = w;
    G[cnt].to = v;
    G[cnt++].from = u;
}

bool Bell_Ford(){
    for(int i = 1; i <= n; ++i)  d[i] = INF;

    d[1] = 0;
    for(int i = 0; i < n; ++i){
        for(int j = 0; j < cnt; ++j){
            int u = G[j].from;
            int v = G[j].to;
            int w = G[j].w;
            if(d[u] < INF && d[v] > d[u] + w){
                d[v] = d[u] + w;
            }
        }
    }

    for(int j = 0; j < cnt; ++j){
        int u = G[j].from;
        int v = G[j].to;
        int w = G[j].w;
        if(d[u] < INF && d[v] > d[u] + w)
            return true;
    }

    return false;
}

int main(){
//    freopen("in.txt", "r", stdin);
    int ml, md, u, v, w;
    cin >> n >> ml >> md;
    cnt = 0;

    for(int i = 0; i < ml; ++i){
        scanf("%d %d %d", &u, &v, &w);
        if(u < v)   swap(u, v);
        add(v, u, w);
    }

    for(int i = 0; i < md; ++i){
        scanf("%d %d %d", &u, &v, &w);
        if(u < v)  swap(u, v);
        add(u, v, -w);
    }

    if(Bell_Ford()) printf("-1
");
    else if(d[n] == INF)  printf("-2
");
    else  printf("%d
", d[n]);
    return 0;
}