差分约束（转最短路问题3）POJ1201

差分约束

POJ 1201

题目大意：给出N组 数据Li,Ri,Xi，意思是在区间[Li,Ri]上最少要选出Xi个数，求总共需要找出最少的数字的总数量

分析：令前i个数中需要挑出d（i）个数字，那么显然d（0）=0；
根据题目翻译成式子就是：d(Ri)-d(Li-1)>=Xi
即d(Li-1)-d(Ri)<=-Xi;
又隐藏了一个条件就是:1>=d(i+1)-d(i)>=0
即d(i+1)-d(i)<=1;
d(i)-d(i+1)<=0;
从这两个式子也可以看出我们构造出的图将会是一个有向图；

我们可以根据这N组数据先找出最左端点minn和最右端点maxx，把所有权值×（-1），然后通过这个关系构造一个带负权的有向图，既然要让取的数字尽可能的少，那么转到路径上的话就是从maxx到minn的最长路径。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<string>
#include<vector>
#include<stack>
#include<bitset>
#include<cstdlib>
#include<cmath>
#include<set>
#include<list>
#include<deque>
#include<queue>
#define ll long long
#define pb push_back
using namespace std;
const int INF=0x3f3f3f3f;
const int maxn=50090;
struct Edge
{
    int v,cost,next;
    Edge(int _v=0,int _cost=0):v(_v),cost(_cost){}
} edge[maxn];
bool vis[maxn];
int d[maxn];
int head[maxn];
int tol;
int SPFA(int sx,int ex)
{
    memset(vis,false,sizeof vis);
    fill(d+ex,d+1+sx,-INF);
    queue<int> q;
    while(!q.empty())q.pop();
    d[sx]=0;
    q.push(sx);
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        vis[u]=false;
        for (int i=head[u]; i!=-1; i=edge[i].next)
        {
            int v=edge[i].v;
            int cost=edge[i].cost;
            if (d[v]<d[u]+cost)
            {
                d[v]=d[u]+cost;
                if (!vis[v])
                {
                    vis[v]=true;
                    q.push(v);
                }
            }
        }
    }
    return d[ex];
}
void add(int u,int v,int w)
{
    edge[tol].v=v;
    edge[tol].cost=w;
    edge[tol].next=head[u];
    head[u]=tol++;
}
int main()
{
    int n,m,a,b,c,tol=0,minn=INF,maxx=-1;
    scanf("%d",&n);
    memset(head,-1,sizeof head);
    for (int i=0; i<n; i++)
    {
        scanf("%d%d%d",&a,&b,&c);
        add(b,a-1,c);
        minn=min(minn,a-1);
        maxx=max(maxx,b);
    }
    for (int i=minn; i<=maxx; i++)
    {
        add(i,i+1,-1);
        add(i+1,i,0);
    }
    cout<<SPFA(maxx,minn)<<endl;
    return 0;
}