Intervals+POJ+差分约束

Intervals

Time Limit: 2000MS

Memory Limit: 65536KB

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 end points 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 <= 50000) -- 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 <= 50000 and 1 <= ci <= bi - ai+1.

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

解决方案：此题可用线段树+贪心来写，这里介绍差分约束的方法。此题可这样子看：设d[i]为0-i能选的数字的个数，那么题目的条件可转化为d[bi]-d[ai-1]>=ci，即d[bi]>=d[ai-1]+w(ai-1,bi)，这样就可以产生一个约束条件，同时这里还有个隐含的约束条件，0<=d[i]-d[i-1]<=1，有了这几个约束条件，问题就转成了求0到max{di}最长路的问题了。

code:
#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#define MMAX 500005
using namespace std;
int head[MMAX],d[MMAX];
bool inqueue[MMAX];
struct edge
{
    int from,to,v;
    int next;
} E[MMAX];
int n,k;
void add_edge(int from,int to,int v)
{
    E[k].from=from;
    E[k].to=to;
    E[k].v=v;
    E[k].next=head[from];
    head[from]=k++;

}
void spfa(){
     for(int i=0;i<MMAX;i++){
        d[i]=-MMAX;
     }
   //  memset(in_cnt,0,sizeof(in_cnt));
     memset(inqueue,false,sizeof(inqueue));
     d[0]=0;
     inqueue[0]=true;
     queue<int>Q;
     Q.push(0);
     while(!Q.empty()){
        int temp=Q.front();
        Q.pop();
        inqueue[temp]=false;
        for(int v=head[temp];v!=-1;v=E[v].next){
            if(d[E[v].to]<d[temp]+E[v].v){
                d[E[v].to]=d[temp]+E[v].v;
                if(!inqueue[E[v].to]){
                    inqueue[E[v].to]=true;
                    Q.push(E[v].to);
                }
            }
        }
     }



}
int main()
{
    while(~scanf("%d",&n)){
        memset(head,-1,sizeof(head));
        int from,to,v;
        k=0;
        int Max=0;
        for(int i=0;i<n;i++){
            scanf("%d%d%d",&from,&to,&v);
            Max=max(to+1,Max);
            add_edge(from,to+1,v);
        }
        for(int i=0;i<=Max;i++) add_edge(i,i+1,0);
        for(int i=1;i<=Max;i++) add_edge(i,i-1,-1);
        spfa();
        printf("%d\n",d[Max]);
    }
    return 0;
}