HDU 1384 Intervals 差分约束

是这样的，差分约束的建图方法就不必细说了，建图的时候，要把每个点看成是在某个区间里取了多少点：比如，d[i]就表示从1到i有多少个点被取到了。这样，对于一个区间[i,j]和c,我们有d[j]-d[i]>=c。这样就很好建图了，然后还有一点，0<=d[i]-d[i-1]<=1，这是隐含的条件，忽略了很要命的。

最后，套上一个spfa跑一跑。经典差分约束喜欢加一个源点好让图联通，但这个就不用考虑这个问题，也不用考虑最长路的正环问题。

#include<iostream>
#include<cstdio>
#include<string.h>
#include<algorithm>
#include<cmath>
#include<queue>
using namespace std;

int n,e,head[50010],d[50010];
bool vis[50010];

struct Edge{
    int to,cost,nex;
}edge[150010];

void addedge(int a,int b,int c)
{
    edge[e].to=b;
    edge[e].cost=c;
    edge[e].nex=head[a];
    head[a]=e++;
}

void spfa(int s)
{
    queue<int> q;
    memset(vis,false,sizeof(vis));
    memset(d,-1,sizeof(d));
    d[s]=0;
    vis[s]=true;
    q.push(s);
    while (!q.empty())
    {
        s=q.front(); q.pop();
        vis[s]=false;
        for (int i=head[s]; i!=-1; i=edge[i].nex)
        {
            int v=edge[i].to;
            if (d[v]<d[s]+edge[i].cost)
            {
                d[v]=d[s]+edge[i].cost;
                if (!vis[v])
                {
                    vis[v]=true;
                    q.push(v);
                }
            }
        }
    }
}

int main()
{
    while (~scanf("%d",&n))
    {
        e=0;
        memset(head,-1,sizeof(head));
        int maxx=0; int minn=50010;
        for (int i=1; i<=n; i++)
        {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            a++; b++;
            maxx=max(maxx,max(a,b));
            minn=min(minn,min(a,b));
            addedge(a-1,b,c);
        }
        for (int i=minn; i<=maxx; i++)
        {
            addedge(i-1,i,0);
            addedge(i,i-1,-1);
        }
        spfa(minn-1);
        printf("%d\n",d[maxx]);
    }
    return 0;
}