POJ - 1201 Intervals 【spfa解决差分约束问题】

题目链接：http://poj.org/problem?id=1201

题目的意思是一个序列在数字上满足约束条件，值在a和b之间的数至少出现c个不同的数，输出满足条件的最短长度。

可以先参考下这个博客：https://blog.youkuaiyun.com/godleaf/article/details/87907527

首先要注意的是给出的a和b中，a要-1，为什么？

因为 [ a, a ] 可以出现1个或者0个，如果我以1为起点，求1到N的序列最短长度，那么给起点初始化的时候不能直接初始化为0，因为d[1] = 1也是有可能的，所以区间要写成 (a-1, a]， 那么这个时候真正的起点就是 d[0]，这个时候就可以初始化为0。 

然后就是整理下样例的约束条件。

d[7] - d[3-1] >= 3 

d[10] - d[8-1] >= 3

d[8] - d[6-1] >= 1

d[3] - d[1-1] >= 1

d[11] - d[10-1] >= 1

除此之外还有一些隐藏的约束条件（这些隐藏的约束条件能保证把构建的整个图形成一个连通图）

d[7] - d[3-1] >= 0  && d[7] - d[3-1] <= 7-3+1 (因为3到7之间只可能出现 7-3+1种不同的数)，其他的隐藏约束条件就不一一写出来了，和上面的一样。

对于最短路径来说，当所有的点到源点的最短距离已经求出来之后，那么任意两个点都满足这个不等式 d[v] - d[u] <= w(u, v)。

对于最长路径来说，当所有的点到源点的最长距离已经求出来之后，那么任意两个点都满足这个不等式 d[v] - d[u] >= w(u, v)。

这时候可以发现，除了d[7] - d[3-1] <= 7-3+1，其他的都和最长路径的不等式一样，那么这个时候我们就能用spfa求最长路来解这道题，那对于d[7] - d[3-1] <= 7-3+1，这个不等式怎么处理？只要两边都乘一个-1，不等式的符号就能换过来了，但是这个时候两点之间方向也会调换，即 d[3-1] - d[7] >= -(7-3+1)。

按照上面的结论给题目构建一个图，要注意方向和权值的正负。

把上面的不等式的符号全部转换成 <= ，然后求最短路应该也是没问题的，不过没去试。

#include <iostream>
#include <queue>
#include <cstring>
#include <string>
#include <map>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <vector>

using namespace std;

#define lson (cur<<1)
#define rson (cur<<1|1)
typedef long long ll;
typedef pair<int, int> pii;

const int INF = 0x3f3f3f3f;
const int Maxn = 5e4+10;
const int Mod = 1e9+7;

struct Edge {
    int v, w;
    Edge(int x = 0, int y = 0): v(x), w(y) {};
} edge[Maxn*3];

vector <int> G[Maxn];
int d[Maxn], cnt[Maxn], Hash[Maxn];
bool vis[Maxn];

void spfa(int N, int E) {
    for(int i = 0; i < N; ++i) {
        d[Hash[i]] = 0; vis[Hash[i]] = false;
        cnt[Hash[i]] = 0;
    }
    queue<Edge> qu;
    vis[Hash[0]] = true;
    qu.push(Edge(Hash[0], 0));

    while (!qu.empty()) {
        int v = qu.front().v; qu.pop();
        vis[v] = false;
        
        for(int i = 0; i < G[v].size(); ++i) {
            Edge &e = edge[G[v][i]];
            if(d[e.v] < d[v]+e.w) {
                d[e.v] = d[v]+e.w;
                if(!vis[e.v]) {
                    vis[e.v] = true;
                    cnt[e.v]++;
                    if(cnt[e.v] > E) return;
                    qu.push(Edge(e.v, d[e.v]));
                }
            }
        }
    }
}

int main(void)
{
    int N;
    scanf("%d", &N);
    int u, v, w, n = 0;
    for(int i = 0; i < N; ++i) {
        scanf("%d%d%d", &u, &v, &w);
        edge[i].v = v; edge[i].w = w;
        G[u-1].push_back(i);
        Hash[n++] = u-1; Hash[n++] = v;
    }
    sort(Hash, Hash+n);
    n = unique(Hash, Hash+n)-Hash;
    for(int i = 0; i < n-1; ++i) {
        edge[i+N].w = 0; edge[i+N].v = Hash[i+1];
        edge[i+N+n-1].w = -(Hash[i+1]-Hash[i]); edge[i+N+n-1].v = Hash[i];
        G[Hash[i]].push_back(i+N);
        G[Hash[i+1]].push_back(i+N+n-1);
    }
    spfa(n, N+2*(n-1));
    printf("%d\n", d[Hash[n-1]]);
    return 0;
}