POJ 3169

题意：一群奶牛，按1~n的顺序站好，站位可以重叠，奶牛与奶牛之间可能有最大或最小距离限制，让你求1号奶牛和n号奶牛之间的最大的距离，没有输出-1，正无穷输出-2。

用差分约束。。。一开始不知道这是啥，看过别人的博客介绍以后就懂了，通俗的说给你一个如下的三角形假如说 b - a <= k1, c - b <= k2, c - a <= k3, 那么从a到c满足的最大距离即 max_distance = min(k1 + k2, k3)。

然后利用这道题给出m1个 d[v] - d[u] <= w, m2个 d[v] - d[u] >= w -> d[u] - d[v] <= -w 和一开始隐含的条件 d[i + 1] - d[i] >= 0-> d[i] - d[i + 1] <= 0，这样就抽象成了一个上述的差分约束的问题，再将不等式建成一个有向图，用Bellman-ford算法模版求最短路即为从1到n的最大值，如果d[n] = INF 说明1和n是无限远，如果有负环说明无解，负责输出d[n]即为1到n的最大值。

附代码：

#include <cstdio>
#include <cstring>
#include <iostream>
#include <vector>
#include <queue>
using namespace std;
int n;
const int INF = 0x7fffffff;
struct Edge
{
    int v, w;
};
vector<Edge> G[1005];
int d[1005];
int vis[1005];
int cnt[1005];
bool bellman_ford(int s)
{
    queue<int> q;
    memset(vis, 0, sizeof(vis));
    memset(cnt, 0, sizeof(cnt));
    for(int i = 1; i <= n; ++i)
        d[i] = INF;
    d[s] = 0;
    vis[s] = 1;
    q.push(s);
    while(!q.empty())
    {
        int u = q.front();
        q.pop();
        vis[u] = 0;
        for(int i = 0; i < G[u].size(); ++i)
        {
            int w = G[u][i].w;
            int v = G[u][i].v;
            if(d[u] < INF && d[v] > d[u] + w)
            {
                d[v] = d[u] + w;
                if(!vis[v])
                {
                    q.push(v);
                    vis[v] = 1;
                    if(++cnt[v] > n)
                        return false;
                }
            }
        }
    }
    return true;
}
int main()
{
    int m1, m2;
    int u, v, w;
    scanf("%d%d%d", &n, &m1, &m2);
    for(int i = 0; i < m1; ++i)
    {
        scanf("%d%d%d", &u, &v, &w);
        G[u].push_back({v, w});
    }
    for(int i = 0; i < m2; ++i)
    {
        scanf("%d%d%d", &u, &v, &w);
        G[v].push_back({u, -w});
    }
    for(int i = 1; i < n; ++i)
    {
        G[i + 1].push_back({i, 0});
    }
    if(!bellman_ford(1))
    {
        printf("-1\n");
    }
    else if(d[n] == INF)
    {
        printf("-2\n");
    }
    else
        printf("%d\n", d[n]);
}