【POJ】【3680】Intervals

网络流/费用流

---

　　引用下题解：

lyd：

首先把区间端点离散化，设原来的数值i离散化后的标号是c[i]。这样离散化之后，整个数轴被分成了一段段小区间。

1.建立S和T，从S到离散化后的第一个点连容量K，费用0的边。离散化后的最后一个点到T连容量K、费用0的边。

2.离散化后的相邻点之间（从i到i+1）连容量为K，费用为0的边。

3.输入的区间从离散化后的左端点到右端点连容量1、费用W的边。

　　感觉好神啊……

其实应该只要把源点到第一个点的流量限制为k应该就可以了……这个构思蛮巧妙的……限制了每个地方最多有k个流出去。

另外，这题是最大费用最大流，所以按上面的建图方式需要改一下预处理和增广的条件，或者就是建图的时候所有的费用取负，再将最后答案取负。

 Source Code
 Problem:         User: sdfzyhy
 Memory: 752K        Time: 563MS
 Language: G++        Result: Accepted

     Source Code

     //BZOJ 3680
     #include<cmath>
     #include<vector>
     #include<cstdio>
     #include<cstring>
     #include<cstdlib>
     #include<iostream>
     #include<algorithm>
     #define rep(i,n) for(int i=0;i<n;++i)
     #define F(i,j,n) for(int i=j;i<=n;++i)
     #define D(i,j,n) for(int i=j;i>=n;--i)
     #define pb push_back
     #define CC(a,b) memset(a,b,sizeof(a))
     using namespace std;
     int getint(){
         int v=,sign=; char ch=getchar();
         while(!isdigit(ch)) {if(ch=='-') sign=-; ch=getchar();}
         while(isdigit(ch))  {v=v*+ch-''; ch=getchar();}
         return v*sign;
     }
     const int N=,M=,INF=~0u>>;
     const double eps=1e-;
     /*******************template********************/
     int n,m,k,ans,a[N],b[N],c[N],w[N];
     struct edge{int from,to,v,c;};
     struct Net{
         edge E[M];
         int head[N],next[M],cnt;
         void ins(int x,int y,int z,int c){
             E[++cnt]=(edge){x,y,z,c};
             next[cnt]=head[x]; head[x]=cnt;
         }
         void add(int x,int y,int z,int c){
             ins(x,y,z,c); ins(y,x,,-c);
         }
         int S,T,d[N],Q[M],from[N];
         bool inq[N];
         bool spfa(){
             int l=,r=-;
             F(i,S,T) d[i]=INF;
             d[S]=; Q[++r]=S; inq[S]=;
             while(l<=r){
                 int x=Q[l++]; inq[x]=;
                 for(int i=head[x];i;i=next[i])
                     if(E[i].v && d[x]+E[i].c<d[E[i].to]){
                         d[E[i].to]=d[x]+E[i].c;
                         from[E[i].to]=i;
                         if (!inq[E[i].to]){
                             Q[++r]=E[i].to;
                             inq[E[i].to]=;
                         }
                     }
             }
             return d[T]!=INF;
         }
         void mcf(){
             int x=INF;
             for(int i=from[T];i;i=from[E[i].from])
                 x=min(x,E[i].v);
             for(int i=from[T];i;i=from[E[i].from]){
                 E[i].v-=x;
                 E[i^].v+=x;
             }
             ans+=x*d[T];
         }
         void init(){
             n=getint(); k=getint();
             cnt=; ans=;
             memset(head,,sizeof head);
             int x,y;
             F(i,,n){
                 a[i]=c[(i<<)-]=getint();
                 b[i]=c[i<<]=getint();
                 w[i]=getint();
             }
             sort(c+,c+n*+);
             int num=unique(c+,c+n*+)-c-;
             S=; T=num+;
             F(i,,num) add(i,i+,k,);
             F(i,,n){
                 a[i]=lower_bound(c+,c+num+,a[i])-c;
                 b[i]=lower_bound(c+,c+num+,b[i])-c;
                 add(a[i],b[i],,-w[i]);
             }
             while(spfa()) mcf();
             printf("%d\n",-ans);
         }
     }G1;
     int main(){
     #ifndef ONLINE_JUDGE
         freopen("input.txt","r",stdin);
     //    freopen("output.txt","w",stdout);
     #endif
         int T=getint();
         while(T--) G1.init();
         return ;
     }

Intervals

Time Limit: 5000MS		Memory Limit: 65536K
Total Submissions: 6880		Accepted: 2859

Description

You are given N weighted open intervals. The ith interval covers (a_i, b_i) and weighs w_i. Your task is to pick some of the intervals to maximize the total weights under the limit that no point in the real axis is covered more than k times.

Input

The first line of input is the number of test case.
The first line of each test case contains two integers, N and K (1 ≤ K ≤ N ≤ 200).
The next N line each contain three integers a_i, b_i, w_i(1 ≤ a_i < b_i ≤ 100,000, 1 ≤ w_i ≤ 100,000) describing the intervals.
There is a blank line before each test case.

Output

For each test case output the maximum total weights in a separate line.

Sample Input

4

3 1
1 2 2
2 3 4
3 4 8

3 1
1 3 2
2 3 4
3 4 8

3 1
1 100000 100000
1 2 3
100 200 300

3 2
1 100000 100000
1 150 301
100 200 300

Sample Output

14
12
100000
100301

Source

POJ Founder Monthly Contest – 2008.07.27, windy7926778

[Submit]   [Go Back]   [Status]   [Discuss]