POJ3169-Layout

首先，牛是按照编号排序的，所以有d[i]<=d[i+1]。

其次，对于每对关系好的牛之间都有d[Al]+Dl>=d[Bl]。

同样，对于每对关系不好的牛之间都有d[Ad]+Dd<=d[Bd]。

d[i]<=d[i+1]变形为d[i+1]+0>=d[i]，因此从顶点i+1向顶点i连一条权值为0的边。

同样，d[Al]+Dl>=d[Bl]对应从顶点Al向顶点Bl连一条权值为d[Bl]的边。

d[Ad]+Dd<=d[Bd]对应从顶点Bd向顶点Ad连一条权值为-Dd的边。

所求问题是d[n]-d[1]的最大值，对应顶点1到顶点n的最小距离。

注意存在负边。

#include <cstdio>
#include <algorithm>

using namespace std;

const int max_ml = 10000 + 10;
const int max_md = 10000 + 10;
const int inf = 1000000000 + 10;
const int maxn = 1000;

int Al[max_ml], Bl[max_ml], Dl[max_ml];
int Ad[max_md], Bd[max_md], Dd[max_md];
int d[maxn];

int main()
{
    int n, ml, md;
    scanf("%d%d%d", &n, &ml, &md);
    
    for (int i = 0; i < ml; i++) {
        scanf("%d%d%d", &Al[i], &Bl[i], &Dl[i]);
    }
    for (int i = 0; i < md; i++) {
        scanf("%d%d%d", &Ad[i], &Bd[i], &Dd[i]);
    }
    
    fill(d, d + n, inf);
    d[0] = 0;
    
    //用Bellman-Ford算法计算d
    for (int k = 0; k < n; k++) {
        //从i+1到i的权值为0
        for (int i = 0; i + 1 < n; i++) {
            if (d[i+1] < inf) {
                d[i] = min(d[i], d[i+1]);
            }
        }
        //从Al到Bl的权值为Dl
        for (int i = 0; i < ml; i++) {
            if (d[Al[i]-1] < inf) {
                d[Bl[i]-1] = min(d[Bl[i]-1], d[Al[i]-1] + Dl[i]);
            }
        }
        //从Bd到Ad的权值为-Dd
        for (int i = 0; i < md; i++) {
            if (d[Bd[i]-1] < inf) {
                d[Ad[i]-1] = min(d[Ad[i]-1], d[Bd[i]-1] - Dd[i]);
            }
        }
    }
    
    int res = d[n-1];
    if (d[0] < 0)
        res = -1;
    else if (res == inf)
        res = -2;
    printf("%d\n", res);
    
    return 0;
};