POJ3680 Intervals —— 区间k覆盖问题（最小费用流）

题目链接：https://vjudge.net/problem/POJ-3680

Intervals

Time Limit: 5000MS		Memory Limit: 65536K
Total Submissions: 8711		Accepted: 3726

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 

题意：

数轴上有一些带权的区间， 选出权值和尽量大的一些区间， 使得任意一个数最多被k个区间覆盖。

题解：

可用最小费用流解决，构图方法如下：

1.把数轴上每个数作为一个点。

2.对于相邻的点，连一条边：i-->i+1， 容量为k， 费用为0。i-->i+1设为k，保证了x-->i（0<=x<i）的流量不高于k。因此，还需在数轴的最右边增加一个汇点， 数轴的最后一个点连向此汇点，容量为k， 费用为0。

3.对于区间[u, v]， 连一条边：u-->v，容量为1， 费用为-w。

4.以数轴最左端的点作为源点，跑最小费用流， 把得到的最小花费取反，即为答案。

5.由于此题数轴的范围比较大，而实际用到的点却很少，所以可以先对数轴进行离散化。

代码如下：

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #include <vector>
 #include <cmath>
 #include <queue>
 #include <stack>
 #include <map>
 #include <string>
 #include <set>
 using namespace std;
 typedef long long LL;
 const int INF = 2e9;
 const LL LNF = 9e18;
 const int mod = 1e9+;
 const int MAXM = 1e5+;
 const int MAXN = +;

 struct Edge
 {
     int to, next, cap, flow, cost;
 }edge[MAXM];
 int tot, head[MAXN];
 int pre[MAXN], dis[MAXN];
 bool vis[MAXN];
 int N;

 void init(int n)
 {
     N = n;
     tot = ;
     memset(head, -, sizeof(head));
 }

 void add(int u, int v, int cap, int cost)
 {
     edge[tot].to = v;  edge[tot].cap = cap;  edge[tot].cost = cost;
     edge[tot].flow = ;   edge[tot].next = head[u];   head[u] = tot++;
     edge[tot].to = u;   edge[tot].cap = ;  edge[tot].cost = -cost;
     edge[tot].flow = ; edge[tot].next = head[v];   head[v] = tot++;
 }

 bool spfa(int s, int t)
 {
     queue<int>q;
     for(int i = ; i<N; i++)
     {
         dis[i] = INF;
         vis[i] = false;
         pre[i] = -;
     }

     dis[s] = ;
     vis[s] = true;
     q.push(s);
     while(!q.empty())
     {
         int u  = q.front();
         q.pop();
         vis[u] = false;
         for(int i = head[u]; i!=-; i = edge[i].next)
         {
             int v = edge[i].to;
             if(edge[i].cap>edge[i].flow && dis[v]>dis[u]+edge[i].cost)
             {
                 dis[v] = dis[u]+edge[i].cost;
                 pre[v] = i;
                 if(!vis[v])
                 {
                     vis[v] = true;
                     q.push(v);
                 }
             }
         }
     }
     if(pre[t]==-) return false;
     return true;
 }

 int minCostMaxFlow(int s, int t, int &cost)
 {
     int flow = ;
     cost = ;
     while(spfa(s,t))
     {
         int Min = INF;
         for(int i = pre[t]; i!=-; i = pre[edge[i^].to])
         {
             if(Min>edge[i].cap-edge[i].flow)
                 Min = edge[i].cap-edge[i].flow;
         }
         for(int i = pre[t]; i!=-; i = pre[edge[i^].to])
         {
             edge[i].flow += Min;
             edge[i^].flow -= Min;
             cost += edge[i].cost*Min;
         }
         flow += Min;
     }
     return flow;
 }

 int interval[][];
 int M[MAXN];
 int main()
 {
     int T, n, k;
     scanf("%d", &T);
     while(T--)
     {
         scanf("%d%d", &n, &k);
         int cnt = ;
         for(int i = ; i<=n; i++)
         {
             scanf("%d%d%d", &interval[i][],&interval[i][],&interval[i][]);
             M[cnt++] = interval[i][];
             M[cnt++] = interval[i][];
         }
         M[cnt++] = INF;
         sort(M, M+cnt);
         cnt = unique(M, M+cnt)-M;

         init(cnt);
         for(int i = ; i<cnt-; i++)
         {
             add(i, i+, k, );
         }
         for(int i = ; i<=n; i++)
         {
             int left = lower_bound(M, M+cnt, interval[i][])-M;
             int right = lower_bound(M, M+cnt, interval[i][])-M;
             add(left, right, , -interval[i][]);
         }

         int min_cost;
         int start = , end = cnt-;
         minCostMaxFlow(start, end, min_cost);
         printf("%d\n", -min_cost);
     }
 }