poj 3680 Intervals(费用流)

题目链接

Intervals

Time Limit: 5000MS		Memory Limit: 65536K
Total Submissions: 7633		Accepted: 3201

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

题解：让区间重复次数小于k，是用流量来限制的，将区间端点离散化处理过后，将每个端点作为一个节点，依次连接，负载为INF，费用为0。addedge(i,i+1,INF,0);对与每个给定的区间（a，b），我们将a，b端点对应的节点相连，负载为1，费用-c；(addedge(hash[l[i]],hash[r[i]],1,-v[i]);)超级源点连节点1，负载为k，费用为0；最后一个端点对应的节点连超级汇点，负载为k(或INF)，费用为0。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;
const int MAXN=400+10;
const int MAXM=MAXN*MAXN;
const int INF=0x3f3f3f3f;
int l[MAXN],r[MAXN],num[MAXN],v[MAXN];
int hash[100000+10];
int tot;
struct Edge  
{  
    int to,next,cap,flow,cost;  
}edge[MAXM];  
int head[MAXN],tol;  
int pre[MAXN],dis[MAXN];  
bool vis[MAXN];  
int N;//节点总个数，节点编号从0~N-1  
void init(int n)  
{  
    N = n;  
    tol = 0;  
    memset(head,-1,sizeof(head));  
}  
void addedge(int u,int v,int cap,int cost)  
{  
    edge[tol].to = v;  
    edge[tol].cap = cap;  
    edge[tol].cost = cost;  
    edge[tol].flow = 0;  
    edge[tol].next = head[u];  
    head[u] = tol++;  
    edge[tol].to = u;  
    edge[tol].cap = 0;  
    edge[tol].cost = -cost;  
    edge[tol].flow = 0;  
    edge[tol].next = head[v];  
    head[v] = tol++;  
}  
bool spfa(int s,int t)  
{  
    queue<int>q;  
    for(int i = 0;i < N;i++)  
    {  
        dis[i] = INF;  
        vis[i] = false;  
        pre[i] = -1;  
    }  
    dis[s] = 0;  
    vis[s] = true;  
    q.push(s);  
    while(!q.empty())  
    {  
        int u = q.front();  
        q.pop();  
        vis[u] = false;  
        for(int i = head[u]; i != -1;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] == -1)return false;  
    else return true;  
}  
//返回的是最大流，cost存的是最小费用  
int minCostMaxflow(int s,int t,int &cost)  
{  
    int flow = 0;  
    cost = 0;  
    while(spfa(s,t))  
    {  
        int Min = INF;  
        for(int i = pre[t];i != -1;i = pre[edge[i^1].to])  
        {  
            if(Min > edge[i].cap - edge[i].flow)  
                Min = edge[i].cap - edge[i].flow;  
        }  
        for(int i = pre[t];i != -1;i = pre[edge[i^1].to])  
        {  
            edge[i].flow += Min;  
            edge[i^1].flow -= Min;  
            cost += edge[i].cost * Min;  
        }  
        flow += Min;  
    }  
    return flow;  
}

int main()
{
	int cas;
	scanf("%d",&cas);
	while(cas--)
	{
		int n,k;
		scanf("%d%d",&n,&k);
		memset(r,0,sizeof(r));
		memset(l,0,sizeof(l));
		memset(hash,0,sizeof(hash));
		tot=0;
		for(int i=1;i<=n;i++)
		{
			scanf("%d%d%d",&l[i],&r[i],&v[i]);
			num[tot++]=l[i],num[tot++]=r[i];
		}
		sort(num,num+tot);
		tot=unique(num,num+tot)-num;
		init(tot+1);
		for(int i=0;i<tot;i++) hash[num[i]]=i+1;
		for(int i=1;i<tot;i++) addedge(i,i+1,INF,0);
		for(int i=1;i<=n;i++) addedge(hash[l[i]],hash[r[i]],1,-v[i]);
		int start=0,end=tot;
		addedge(0,1,k,0);
		int cost;
		minCostMaxflow(start,end,cost);
		printf("%d\n",-cost);
	}
}