POJ 3680 Intervals

传说中的区间k覆盖问题。

给定n个带权开区间，选择其中一些使得区间权值之和最大，且所有区间内任意点被覆盖不能超过k次。

建图方法：

1.将区间离散化，对于离散化后的区间端点所对应的点i,i+1，加边(i,i+1,k,0)

2.对于每个区间(a,b)，所对应离散化后的点(xx,yy)，加边(xx,yy,-w,1)，w为区间的权值

3.由源点src连一条到一个点的边(src,1,k,0),同理，由最后一个点t连一条道汇点sink的边(t,sink,k,0)

跑一遍最小费用了取反即为结果。

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <queue>
#define maxn 410
#define maxm 2010
#define INF 1<<30
using namespace std;
struct MCMF{
    int src,sink,e,n;
    int first[maxn];
    int cap[maxm],cost[maxm],v[maxm],next[maxm];
    bool flag;
    void init(){
        e = 0;
        memset(first,-1,sizeof(first));
    }

    void add_edge(int a,int b,int cc,int ww){
        //printf("add:%d to %d,cap = %d,cost = %d
",a,b,cc,ww);
        cap[e] = cc;cost[e] = ww;v[e] = b;
        next[e] = first[a];first[a] = e++;
        cap[e] = 0;cost[e] = -ww;v[e] = a;
        next[e] = first[b];first[b] = e++;
    }

    int d[maxn],pre[maxn],pos[maxn];
    bool vis[maxn];

    bool spfa(int s,int t){
        memset(pre,-1,sizeof(pre));
        memset(vis,0,sizeof(vis));
        queue<int> Q;
        for(int i = 0;i <= n;i++)   d[i] = INF;
        Q.push(s);pre[s] = s;d[s] = 0;vis[s] = 1;
        while(!Q.empty()){
            int u = Q.front();Q.pop();
            vis[u] = 0;
            for(int i = first[u];i != -1;i = next[i]){
                if(cap[i] > 0 && d[u] + cost[i] < d[v[i]]){
                    d[v[i]] = d[u] + cost[i];
                    pre[v[i]] = u;pos[v[i]] = i;
                    if(!vis[v[i]])  vis[v[i]] = 1,Q.push(v[i]);
                }
            }
        }
        return pre[t] != -1;
    }

    int Mincost;
    int Maxflow;

    int MinCostFlow(int s,int t,int nn){
        Mincost = 0,Maxflow = 0,n = nn;
        while(spfa(s,t)){
            int min_f = INF;
            for(int i = t;i != s;i = pre[i])
                if(cap[pos[i]] < min_f) min_f = cap[pos[i]];
            Mincost += d[t] * min_f;
            Maxflow += min_f;
            for(int i = t;i != s;i = pre[i]){
                cap[pos[i]] -= min_f;
                cap[pos[i]^1] += min_f;
            }
        }
        return Mincost;
    }
};
MCMF g;

struct Line{
    int a,b,w;
}line[210];
int x[410];

int main(){
    int T;
    scanf("%d",&T);
    while(T--){
        g.init();
        int N,K;
        scanf("%d%d",&N,&K);
        int cnt = 0;
        for(int i = 0;i < N;i++){
            int a,b,w;
            scanf("%d%d%d",&a,&b,&w);
            x[cnt++] = a;x[cnt++] = b;
            line[i].a = a;line[i].b = b;line[i].w = w;
        }
        sort(x,x+cnt);
        int t = unique(x,x+cnt) - x;
        //printf("t = %d
",t);
        for(int i = 0;i < N;i++){
            int xx = lower_bound(x,x+t,line[i].a) - x + 1;
            int yy = lower_bound(x,x+t,line[i].b) - x + 1;
            g.add_edge(xx,yy,1,-line[i].w);
        }
        for(int i = 1;i < t;i++){
            g.add_edge(i,i+1,K,0);
        }
        int src = t+1,sink = src+1;
        g.add_edge(src,1,K,0);
        g.add_edge(t,sink,K,0);
        int ans = g.MinCostFlow(src,sink,sink);
        printf("%d
",-ans);
    }
    return 0;
}