POJ 3680 Intervals(离散化+费用流)

POJ 3680 Intervals(离散化+费用流)

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

题意:

       给定n个带权开区间，选择其中一些区间出来,使得权值最大并且在任意被选区间的有效点上重叠层数不超过k。

分析:

       本题用费用流解,下面先说说如何建图然后在画图分析为什么这么建图能得到解,将所有区间的前后两个端点离散化为n个不重复的点,然后建图:

       源点s编号0, 区间端点编号1到n, 汇点t编号n+1.

       从s到1号点有边(s, 1, k, 0)

       从i号节点到i+1号节点有边(i, i+1, INF, 0)

       从n号节点到t有边(n, t, k, 0)

       如果区间(a,b)的端点a和b分别是离散化后的第i和第j个点,那么有边(i, j, 1, -w)注意:这里花费取原本区间权值的负数,因为这样我们最后求得的最小费用就是最大权值和的负数.

       最终我们求得的最小费用(该值为负数)的绝对值就是最大权值和.

       下面分析下该构图为什么能得到解?

       从源点流出了k个流量,那么这k个流量可以选择从i到i+1这种普通边流(因为该边的容量无限大),但是如果此时在i到i+1之间有另外一条区间边时(区间边费用为负值), 由于我们求最小费用,所有k个流量中的一个肯定会沿着这条cost为负的区间边流. 这是如果我们算最小费用,那么就会把该区间边的最小费用算上去一次.

       同理如果i到i+1点之间除了普通边外,同时还有2条区间边(区间边cost都为负值),那么明显k个流量肯定先分出两个1的流量分别走这两条区间边,剩下的才去走那些个普通边(因为普通边cost为0,区间边cost为负).

       如果i到i+1除了普通边1条外,还有8条权值不同的区间边,且k=3,那么我们肯定是选权值最小的那3条区间边去走,而不会去走另外权值大些的路.

AC代码:

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<vector>
#include<map>
#define INF 1e9
using namespace std;
const int maxn= 400+5;

struct Edge
{
    int from,to,cap,flow,cost;
    Edge(){}
    Edge(int f,int t,int c,int fl,int co):from(f),to(t),cap(c),flow(fl),cost(co){}
};

struct MCMF
{
    int n,m,s,t;
    vector<Edge> edges;
    vector<int> G[maxn];
    int d[maxn];
    int p[maxn];
    int a[maxn];
    bool inq[maxn];

    void init(int n,int s,int t)
    {
        this->n=n, this->s=s, this->t=t;
        edges.clear();
        for(int i=0;i<n;++i) G[i].clear();
    }

    void AddEdge(int from,int to,int cap,int cost)
    {
        edges.push_back(Edge(from,to,cap,0,cost));
        edges.push_back(Edge(to,from,0,0,-cost));
        m=edges.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);
    }

    bool BellmanFord(int &flow,int &cost)
    {
        for(int i=0;i<n;++i) d[i]=INF;
        queue<int> Q;
        memset(inq,0,sizeof(inq));
        d[s]=0,a[s]=INF,p[s]=0,Q.push(s),inq[s]=true;

        while(!Q.empty())
        {
            int u=Q.front(); Q.pop();
            inq[u]=false;
            for(int i=0;i<G[u].size();++i)
            {
                Edge &e=edges[G[u][i]];
                if(e.cap>e.flow && d[e.to]>d[u]+e.cost)
                {
                    d[e.to]=d[u]+e.cost;
                    p[e.to]=G[u][i];
                    a[e.to]=min(a[u], e.cap-e.flow);
                    if(!inq[e.to]){ inq[e.to]=true; Q.push(e.to); }
                }
            }
        }
        if(d[t]==INF) return false;
        flow += a[t];
        cost += a[t]*d[t];
        int u=t;
        while(u!=s)
        {
            edges[p[u]].flow += a[t];
            edges[p[u]^1].flow -=a[t];
            u=edges[p[u]].from;
        }
        return true;
    }

    int solve()
    {
        int flow=0, cost=0;
        while(BellmanFord(flow,cost));
        return cost;
    }
}MM;

int x[maxn],y[maxn],w[maxn];//从1开始标号,记录每个区间
int p[maxn];//离散化后的每个点
int num;//离散化去重后的点数目

int main()
{
    int T; scanf("%d",&T);
    while(T--)
    {
        int n,k;
        num=0;
        scanf("%d%d",&n,&k);
        for(int i=1;i<=n;++i)
        {
            scanf("%d%d%d",&x[i],&y[i],&w[i]);
            p[num++]=x[i];
            p[num++]=y[i];
        }
        sort(p,p+num);
        num = unique(p,p+num)-p;
        map<int,int> mp;//坐标与编号的映射
        for(int i=0;i<num;++i) mp[p[i]]=i+1;

        int src=0, dst=num+1;
        MM.init(num+2,src,dst);
        MM.AddEdge(src,1,k,0);
        for(int i=1;i<=num;++i) MM.AddEdge(i,i+1,INF,0);
        for(int i=1;i<=n;++i)
        {
            MM.AddEdge(mp[x[i]],mp[y[i]],1,-w[i]);
        }
        printf("%d\n",-MM.solve());
    }
    return 0;
}