HDU 1384 Intervals（差分约束）

Intervals

Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 4292    Accepted Submission(s):
1624

Problem 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

 

Author

1384

 

需要求S[r]-S[l-1]>=ans，即S[l-1]-S[r]<=-ans。若以r为起点 ，而-ans就为r到l-1的最短路径，即-dist[Maxl-1]。

 #include<cstdio>
 #include<cstring>
 #include<queue>
 #include<algorithm>
 #define MAXN 50100
 using namespace std;

 struct Edge{
     int to,nxt,w;
 }e[MAXN<<];
 int dis[MAXN],head[MAXN];
 bool vis[MAXN];
 int cnt,n,l,r;
 queue<int>q;

 void init()
 {
     memset(head,,sizeof(head));
     cnt = ;
     l = ;
     r = ;
 }
 void add(int u,int v,int w)
 {
     ++cnt;
     e[cnt].w = w;
     e[cnt].to = v;
     e[cnt].nxt = head[u];
     head[u] = cnt;
 }
 void spfa()
 {
     memset(dis,0x3f,sizeof(dis));
     memset(vis,false,sizeof(vis));
     q.push(r);
     vis[r] = true;
     dis[r] = ;
     while (!q.empty())
     {
         int u = q.front();
         q.pop();
         for (int i=head[u]; i; i=e[i].nxt)
         {
             int v = e[i].to;
             int w = e[i].w;
             if (dis[v]>dis[u]+w)
             {
                 dis[v] = dis[u]+w;
                 if (!vis[v])
                 {
                     vis[v] = true;
                     q.push(v);
                 }
             }
         }
         vis[u] = false ;
     }
     printf("%d\n",-dis[l-]);
 }
 int main()
 {
     while (scanf("%d",&n)!=EOF)
     {
         init()
         for (int a,b,c,i=; i<=n; ++i)
         {
             scanf("%d%d%d",&a,&b,&c);
             l = min(l,a);
             r = max(r,b);
             add(b,a-,-c);    //b-(a-1)>=c
         }
         for (int i=l; i<=r; ++i)
         {
             add(i,i-,);    //i-(i-1)>=0
             add(i-,i,);    //i-(i-1)<=1
         }
         spfa();
     }
     return ;
 }