Time Limit: 5000MS | Memory Limit: 65536K | |
Total Submissions: 7633 | Accepted: 3201 |
Description
You are given N weighted open intervals. The ith interval covers (ai, bi) and weighs wi. 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 ai, bi, wi(1 ≤ ai < bi ≤ 100,000, 1 ≤ wi ≤ 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);
}
}