poj 3169 Layout (差分约束)

题目连接：

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

题目大意：

　　在一个农场里，等待喂养的牛都按照自己的编号从1—>n排列，但是牛之间有一些特殊的关系，比如牛i与牛j相互讨厌（关系1），那么这两只牛之间最少间隔x，牛i与牛j相互喜欢（关系2），那么这两只牛之间最多间隔x。一共有n头牛，ml个关系2，有md个关系1。问：在满足这约束条件后，1到n的最大距离为多少，如果存在负环输出-1，不存在最长距离输出-2，否则输出最长距离。

解题思路：

　　典型的差分约束问题，但是这个比较麻烦的是，有最大约束还有最小约束。（dist[i]表示的从1到i的最长距离）

　　喜欢的关系存在：（i<j）dist[j] - dist[i] <= x。等价于：dist[j] <= dist[i]  + x。

　　讨厌的关系存在：（i<j）dist[j] - dist[i] >= x。等价于：dist[i] <= dist[j] + x。

　　经过推导，可以看出用spfa求最短路即可，这道题目的关键在于建图。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <vector>
using namespace std;

#define INF 0x3f3f3f3f
#define maxn 1010

struct Edge
{
    int e, w;
    Edge(int e=0, int w=0):e(e),w(w){}
};

vector<Edge> G[maxn];
int dist[maxn];
void init ();
int spfa (int n);

int main()
{
    int n, ml, md;
    while (scanf ("%d %d %d", &n, &ml, &md) != EOF)
    {
        init ();
        int a, b, d;
        while (ml --)
        {
            scanf ("%d %d %d", &a, &b, &d);
            G[a].push_back(Edge(b, d));//对第二种关系正向建边
        }
        while (md --)
        {
            scanf ("%d %d %d", &a, &b, &d);
            G[b].push_back(Edge(a, -d));//对第一种关系反向建边
        }
        printf ("%d
", spfa(n));
    }
    return 0;
}
void init ()
{
    int i;
    for (i=0; i<maxn; i++)
    {
        G[i].clear();
        dist[i] = INF;
    }
}
int spfa (int n)
{
    int vis[maxn], updata[maxn];
    queue<int>Q;
    memset (vis, 0, sizeof(vis));
    memset (updata, 0, sizeof(updata));
    Q.push (1);
    updata[1] = 1;
    dist[1] = 0;
    while (!Q.empty())
    {
        int p = Q.front();
        Q.pop();
        vis[p] = 0;
        int len = G[p].size();

        for (int i=0; i<len; i++)
        {
            Edge q = G[p][i];
            if (dist[q.e] > dist[p] + q.w)
            {
                dist[q.e] = dist[p] + q.w;
                updata[q.e] ++;
                Q.push (q.e);
                vis[q.e] = true;
                if (updata[q.e] == n)
                    return -1;//有负环
            }
        }
    }
    if (dist[n] == INF)
        return -2;//无最长距离的路存在
    return dist[n];
}