POJ No.3680 Intervals

2016-06-01 22:01:39

题目链接: POJ No.3680 Intervals

题目大意:

　　给定N个带权区间,最多可以重复选一个点M次,求出一种选法使得所得权最大

解法:

　　费用流

　　建模:

　　　　区间的端点之间按照副权流量1连接,而每个点之间需要再连0权流量无穷作为跳过用

注意的地方:

　　十万个点肯定是不行的,看我unique离散化大法

//Intervals (POJ No.3680)
//费用流
#include<stdio.h>
#include<algorithm>
#include<queue>
using namespace std;
const int maxn=410;
int T,N,K;
int hash[maxn];
int a[maxn];
int w[maxn];
struct edge 
{
    int to;
    int from;
    int cost;
    int flow;
    int next;
    edge(){}
    edge(int from,int to,int cost,int flow,int next):from(from),to(to),cost(cost),flow(flow),next(next){}
};
edge n[maxn*10];
int cnt;
int len;
int now;
int head[maxn];
bool vis[maxn];
int dist[maxn];
int pre[maxn];
queue <int> q;
void insert(int x,int y,int z,int cost)
{
    n[++cnt]=edge(x,y,cost,z,head[x]);
    head[x]=cnt;
    n[++cnt]=edge(y,x,-cost,0,head[y]);
    head[y]=cnt;
    return ;
}
void SPFA(int s,int t)
{
    fill(dist,dist+maxn,100000);
    q.push(s);
    vis[s]=1;
    dist[s]=0;
    while(!q.empty())
    {
        now=q.front();
        q.pop();
        vis[now]=0;
        for(int i=head[now];i;i=n[i].next)
        {
            if(n[i].flow>0)
            {
                if(dist[n[i].to]>dist[now]+n[i].cost)
                {
                    dist[n[i].to]=dist[now]+n[i].cost;
                    pre[n[i].to]=i;
                    if(!vis[n[i].to])
                    {
                        vis[n[i].to]=1;
                        q.push(n[i].to);
                    }
                }
            }
        }
    }
    for(int i=pre[t];i;i=pre[n[i].from])
    {
        n[i].flow--;
        n[i^1].flow++;
    }
    return ;
}
int Mincost_flow(int s,int t,int num)
{
    int ans=0;
    while(num--)
    {
        SPFA(s,t);
        ans+=dist[t];
    }
    return -ans;
}
int main()
{
    scanf("%d",&T);
    while(T--)
    {
        cnt=1;
        fill(head,head+maxn,0);
        scanf("%d %d",&N,&K);
        for(int i=1;i<=N;i++)
        {
            scanf("%d %d",&a[i*2-1],&a[i*2]);
            scanf("%d",&w[i]);
            hash[i*2-1]=a[i*2-1];
            hash[i*2]=a[i*2];
        }
        sort(hash+1,hash+2*N+1);
        len=unique(hash+1,hash+2*N+1)-hash-1;
        for(int i=1;i<=N*2;i++)
        {
            a[i]=lower_bound(hash+1,hash+len+1,a[i])-hash;
            if(!(i&1))insert(a[i-1],a[i],1,-w[i/2]);
        }
        for(int i=1;i<len;i++)insert(i,i+1,100000,0);
        insert(len,len+1,K,0);
        insert(0,1,K,0);
        printf("%d
",Mincost_flow(0,len+1,K));
    }
}