Intervals(差分约束)

B - Intervals
Time Limit:5000MS Memory Limit:32768KB
64bit IO Format:%I64d & %I64u

Description

You are given n closed, integer intervals [ai, bi] and n integers c1, …, cn.

Write a program that:

reads the number of intervals, their endpoints and integers c1, …, cn from the standard input,

computes the minimal size of a set Z of integers which has at least ci common elements with interval [ai, bi], for each i = 1, 2, …, n,

writes the answer to the standard output

Input

The first line of the input contains an integer n (1 <= n <= 50 000) - the number of intervals. The following n lines describe the intervals. The i+1-th line of the input contains three integers ai, bi and ci separated by single spaces and such that 0 <= ai <= bi <= 50 000 and 1 <= ci <= bi - ai + 1.

Process to the end of file.

Output

The output contains exactly one integer equal to the minimal size of set Z sharing at least ci elements with interval [ai, bi], for each i = 1, 2, …, n.

Sample Input

5
3 7 3
8 10 3
6 8 1
1 3 1
10 11 1

Sample Output

6
题目大意：给出条件在各个区间内至少取多少个数，求一共最少取多少数。
分析：由题意将条件转化可知，用差分约束解决，若以[Si,Sj]表示区间，k代表区间内至少取得个数，那么令Sj-S(i-1)>=k，只是条件之一，因为求最少取多少数，那么每个数都不会取重复的，所以对任意i，都有0<=Si-S(i-1)<=1，这是第二个条件，再通过变形成最短路的状态转移方程，建图，求最短路即可
代码：

#include<iostream>
#include<algorithm>
#include<string.h>
#include<cstring>
#include<cstdio>
#include<queue>
#define inf 0x3f3f3f3f
#define maxn 50005
using namespace std;
struct node
{
    int en;
    int len;
    int next;
};
int num;
int head[maxn];
node E[3*maxn];
bool vis[maxn];
int dis[maxn];
int n;
void init()
{
     num=0;
     memset(head,-1,sizeof(head));
}
void add(int st,int en,int len)
{
    E[num].en=en;
    E[num].len=len;
    E[num].next=head[st];
    head[st]=num++;
}
void spfa(int st,int en)
{
    memset(vis,false,sizeof(vis));
    memset(dis,inf,sizeof(dis));
    queue<int> q;
    vis[st]=true;
    dis[st]=0;
    q.push(st);
    while(!q.empty())
    {
        int xx=q.front();
        q.pop();
        vis[xx]=false;
        for(int i=head[xx];i!=-1;i=E[i].next)
        {
            int ed=E[i].en;
            if(dis[ed]>dis[xx]+E[i].len)
            {
                dis[ed]=dis[xx]+E[i].len;
                if(!vis[ed])
                {
                    q.push(ed);
                    vis[ed]=true;
                }
            }
        }
    }
    printf("%d\n",-dis[en]);//转化后路径为负边权，最终答案为负，所以求其相反数
}
int main()
{
    int i,j,k,a,b,c,max1,min1;
    while(scanf("%d",&n)!=EOF)
    {
        init();
        max1=-inf;min1=inf;
        for(i=1;i<=n;i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            a+=1;b+=1;
            max1=max(max1,max(a,b));//求总的区间
            min1=min(min1,min(a,b));
            add(b,a-1,-c);
        }
        for(i=min1;i<=max1;i++)
        {
            add(i-1,i,1);
            add(i,i-1,0);
        }
        spfa(max1,min1-1);
    }
    getchar();
    getchar();
    return 0;
}