POJ 3680 Intervals 费用流

http://poj.org/problem?id=3680

题目大意：给$n$个开区间，每一个区间都有对应的权值，让你从这$n$个区间中任意选取若干个区间，使得权值之和最大且在实数轴上每个数被覆盖的次数$<=k$，输出这个最大的权值。

思路：费用流，这玩意第一次见真的头大。下面这个解释我觉得还行，然后补充一下细节，区间左端点向右端点连的边的权值是$-w_i$(因为$w_i>=1$)，所以这样求出的最小费用取反后就是最大的权值，然后就是点的范围比较大，所以需要离散化。至于建图过程嘛，比较艺术，不想解释。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#define INF 0x3f3f3f3f
using namespace std;
typedef long long ll;

const int maxn=1005;
const int maxm=2005;

struct Edge
{
    int to,nxt,dis,f;
}edge[maxm<<1];

int n,s,t,k,tot;
int head[maxn],dis[maxn],vis[maxn],pre[maxn],maxf[maxn];
int l[maxn],r[maxn],a[maxn],b[maxn]; //用于离散化

inline void addedge(int u,int v,int f,int dis)
{
    edge[++tot].to=v,edge[tot].nxt=head[u],edge[tot].f=f,edge[tot].dis=dis,head[u]=tot;
    edge[++tot].to=u,edge[tot].nxt=head[v],edge[tot].f=0,edge[tot].dis=-dis,head[v]=tot;
}

bool spfa()
{
    memset(dis,INF,sizeof(dis));
    queue<int> q;
    dis[s]=0,vis[s]=1,maxf[s]=INF;
    q.push(s);
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        vis[u]=0;
        for(int i=head[u];i;i=edge[i].nxt)
        {
            int v=edge[i].to;
            if(edge[i].f&&dis[v]>dis[u]+edge[i].dis)
            {
                dis[v]=dis[u]+edge[i].dis;
                pre[v]=i;
                maxf[v]=min(maxf[u],edge[i].f);
                if(!vis[v])
                    q.push(v),vis[v]=1;
            }
        }
    }
    return dis[t]!=INF;
}


int MCMF()
{
    int mcost=0;
    while(spfa())
    {
        int u=t,v;
        while(u!=s)
        {
            v=pre[u];
            edge[v].f-=maxf[t];
            edge[v^1].f+=maxf[t];
            u=edge[v^1].to;
        }
        mcost+=dis[t]*maxf[t];
    }
    return -mcost;
}

int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d %d",&n,&k);
        memset(head,0,sizeof(head));
        tot=1;
        int len=0;
        for(int i=0;i<n;i++)
        {
            scanf("%d %d %d",&l[i],&r[i],&a[i]);
            b[++len]=l[i],b[++len]=r[i];
        }
        sort(b+1,b+len+1);
        len=unique(b+1,b+len+1)-b-1;
        s=0,t=len+1;
        for(int i=0;i<=len;i++)
            addedge(i,i+1,k,0);
        for(int i=0;i<n;i++)
        {
            l[i]=lower_bound(b+1,b+len+1,l[i])-b;
            r[i]=lower_bound(b+1,b+len+1,r[i])-b;
            addedge(l[i],r[i],1,-a[i]);
        }
        printf("%d\n",MCMF());
    }
    return 0;
}