POJ 2680 Intervals 费用流

题目大意：给你n个区间，每个区间有一个权w，你要从中选若干个区间，使得区间权的和最大。但是现在有一个限制条件，我们把选择一个区间(a,b)，认为是把(a,b)的数字覆盖一次。你选择的若干区间，同一个数字的最大覆盖次数不能超过k次。

建图还是很有意思的，先把区间端点离散为1到tol，tol个点。建图，对于0到tol，建边（ i,i+1,容量为k,费用为0）（这里的本质其实是0到1的容量为k，tol到tol+1的容量为k，其他容量为无限大），这里，是把0视为源点，tol+1视为汇点。对于每个区间，建边（a，b，1，-w）。此图的最小费用流就是答案。

//#pragma comment(linker, "/STACK:102400000,102400000")
#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
#include<cmath>
#include<cctype>
#include<string>
#include<algorithm>
#include<iostream>
#include<ctime>
#include<map>
#include<set>
using namespace std;
#define MP(x,y) make_pair((x),(y))
#define PB(x) push_back(x)
typedef __int64 LL;
//typedef unsigned __int64 ULL;
/* ****************** */
const int INF=100011122;
const double INFF=1e100;
const double eps=1e-8;
const LL mod=9999991;
const int NN=405;
const int MM=2000010;
/* ****************** */

struct G
{
    int u,v,cap,cost,next;
}E[NN*2*2];
int p[NN],T;
int dd[NN],tp[NN],qw[NN],ff[NN],pre[NN];
bool inq[NN];
int tf[NN],a[NN],b[NN],c[NN];

void add(int u,int v,int cap,int cost)
{
    E[T].u=u;
    E[T].v=v;
    E[T].cap=cap;
    E[T].cost=cost;
    E[T].next=p[u];
    p[u]=T++;

    E[T].u=v;
    E[T].v=u;
    E[T].cap=0;
    E[T].cost=-cost;
    E[T].next=p[v];
    p[v]=T++;
}

bool find_path(int st,int en,int n,int &flow,int &cost)
{
    int i,u,v,head,tail;
    for(i=0;i<=n;i++)
    {
        dd[i]=INF;
        inq[i]=false;
        ff[i]=0;
    }
    dd[st]=0;
    head=tail=0;
    qw[tail++]=st;
    inq[st]=true;
    ff[st]=INF;

    while(head!=tail)
    {
        u=qw[head++];
        if(head==NN)
            head=0;
        inq[u]=false;
        for(i=p[u];i+1;i=E[i].next)
        {
            if(E[i].cap>0)
            {
                v=E[i].v;
                if(dd[v]>dd[u]+E[i].cost)
                {
                    dd[v]=dd[u]+E[i].cost;
                    pre[v]=i;
                    ff[v]=min(ff[u],E[i].cap);
                    if(!inq[v])
                    {
                        qw[tail++]=v;
                        inq[v]=true;
                        if(tail==NN)
                            tail=0;
                    }
                }
            }
        }
    }

    if(dd[en]==INF)
        return false;

    flow+=ff[en];
    cost+=dd[en]*ff[en];
    u=en;
    while(u!=st)
    {
        E[ pre[u] ].cap-=ff[en];
        E[ pre[u]^1 ].cap+=ff[en];
        u=E[ pre[u] ].u;
    }
    return true;
}

int MINcost(int st,int en,int n)
{
    int f=0,cost=0;
    while( find_path(st,en,n,f,cost) )
    {
        ;
    }
    return cost;
}

int main()
{
    int cas,n,k;
    int tol,i,u,v,ans;
    scanf("%d",&cas);
    while(cas--)
    {
        scanf("%d%d",&n,&k);
        tol=0;
        for(i=1;i<=n;i++)
        {
            scanf("%d%d%d",&a[i],&b[i],&c[i]);
            tf[++tol]=a[i];
            tf[++tol]=b[i];
        }

        sort(tf+1,tf+1+tol);
        tol=unique(tf+1,tf+1+tol)-tf-1;

        memset(p,-1,sizeof(p));
        T=0;

        for(i=0;i<=tol;i++)
                add(i,i+1,k,0);
        for(i=1;i<=n;i++)
        {
            u=lower_bound(tf+1,tf+1+tol,a[i])-tf;
            v=lower_bound(tf+1,tf+1+tol,b[i])-tf;
            add(u,v,1,-c[i]);
        }

        ans=MINcost(0,tol+1,tol+1);
        printf("%d\n",-ans);
    }
    return 0;
}