HDU 1384 Intervals（差分约束）

题目链接：Click here~~

题意：

给出 n 个区间，每个区间有个权值 Ci，最终找出一个最少的数字的集合，使得满足每个区间中至少包含 Ci 个数。

解题思路：

算法介绍

如果一个系统由n个变量和m个约束条件组成，其中每个约束条件形如xj-xi<=bk(i,j∈[1,n],k∈[1,m]),则其为差分约束系统(system of difference constraints)。亦即，差分约束系统是关于一组变量的特殊不等式组。求解差分约束系统，可以转化成图论的单源最短路径问题。

观察xj-xi<=bk，会发现它类似最短路中的三角不等式d[v]<=d[u]+w[u,v]，即d[v]-d[u]<=w[u,v]。因此，以每个变量xi为结点，对于约束条件xj-xi<=bk，连接一条边(i,j)，边权为bk。我们再增加一个源点s,s与所有点相连，边权均为0。对这个图，以s为源点运行bellman-ford算法，最终{d[i]}即为一组可行解。(差分约束系统的解的一个特点是，当将所有变量同时增加相同的大小，约束条件依然成立）

看了 KIDx 大牛的博客，大概懂了。

将 [0,n] 中的所有数字抽象成点，且 d[i] 表示区间 [0,i] 中包含的集合中数字的个数。

发现对于问题"区间 [a,b] 中包含的集合中数字的个数"，满足区间减法的性质，即 d[b] - d[a-1]。

从而对应住题目中的约束条件，即 d[b] - d[a-1] >= Ci，可以建边 a-1 -> b ，权值为 Ci，再求最长路。

另外，对于此类题目，还需要挖掘出题目的隐含条件，对于此题，即 d[i] - d[i-1] >= 0 ，d[i] - d[i-1] <= 1。符号不一致的，转成负边再建边。

最后，还需要增加一个源点 s ，与所有点相连，边权为0，由于上面的隐含条件，此题就不需要连了。

不过还不清楚为什么要增加源点。增加源点，是为了防止图不连通。

小细节：由于 a-1 可能等于 -1，所以要把所有点映射成 +1 的点。

#include <queue>
#include <stdio.h>
#include <string.h>
#include <algorithm>

using namespace std;

template<int N,int M>
struct Graph
{
    int top;
    struct Vertex{
        int head;
    }V[N];
    struct Edge{
        int v,next;
        int w;
    }E[M];
    void init(){
        memset(V,-1,sizeof(V));
        top = 0;
    }
    void add_edge(int u,int v,int w){
        E[top].v = v;
        E[top].w = w;
        E[top].next = V[u].head;
        V[u].head = top++;
    }
};

Graph<50005,150005> g;

const int N = 5e4 + 5;

int d[N],inqCnt[N];

bool inq[N];

bool spfa(int s,int n)
{
    memset(inqCnt,0,sizeof(inqCnt));
    memset(inq,false,sizeof(inq));
    memset(d,-63,sizeof(d));
    queue<int> Q;
    Q.push(s);
    inq[s] = true;
    d[s] = 0;
    while(!Q.empty())
    {
        int u = Q.front();
        for(int i=g.V[u].head;~i;i=g.E[i].next)
        {
            int v = g.E[i].v;
            int w = g.E[i].w;
            if(d[u] + w > d[v])
            {
                d[v] = d[u] + w;
                if(!inq[v])
                {
                    Q.push(v);
                    inq[v] = true;
                    if(++inqCnt[v] > n)
                        return true;
                }
            }
        }
        Q.pop();
        inq[u] = false;
    }
    return false;
}

int main()
{
    int n;
    while(~scanf("%d",&n))
    {
        g.init();
        int L = 50005 , R = 0;
        for(int i=0;i<n;i++)
        {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            ++a , ++b;
            L = min(L,a);
            R = max(R,b);
            g.add_edge(a-1,b,c);
        }
        for(int i=L;i<=R;i++)
        {
            g.add_edge(i-1,i,0);
            g.add_edge(i,i-1,-1);
        }
        spfa(L-1,R-L+2);
        printf("%d\n",d[R]);
    }
    return 0;
}