线性规划与网络流24——最长k可重区间集问题

题目链接点这里

，k条最大权不相交路径

题解我就照搬其他博客的了。。。（个人觉得方法一这是这一类题目的标准解法，而方法二则是根据本题的特点设计的）

【建模方法】

方法1

按左端点排序所有区间，把每个区间拆分看做两个顶点<i.a><i.b>，建立附加源S汇T，以及附加顶点S’。

1、连接S到S’一条容量为K，费用为0的有向边。
2、从S’到每个<i.a>连接一条容量为1，费用为0的有向边。
3、从每个<i.b>到T连接一条容量为1，费用为0的有向边。
4、从每个顶点<i.a>到<i.b>连接一条容量为1，费用为区间长度的有向边。
5、对于每个区间i，与它右边的不相交的所有区间j各连一条容量为1，费用为0的有向边。

求最大费用最大流，最大费用流值就是最长k可重区间集的长度。

方法2

离散化所有区间的端点，把每个端点看做一个顶点，建立附加源S汇T。

1、从S到顶点1（最左边顶点）连接一条容量为K，费用为0的有向边。
2、从顶点2N（最右边顶点）到T连接一条容量为K，费用为0的有向边。
3、从顶点i到顶点i+1(i+1<=2N)，连接一条容量为无穷大，费用为0的有向边。
4、对于每个区间[a,b]，从a对应的顶点i到b对应的顶点j连接一条容量为1，费用为区间长度的有向边。

求最大费用最大流，最大费用流值就是最长k可重区间集的长度。

#include<iostream>
#include<map>
#include<stdio.h>
#include<algorithm>
#include<queue>
#include<set>
#include<string.h>
#include<string>
#include<vector>
#define MX 1111
#define INF 0x3f3f3f3f
#define mem(x,y) memset(x,y,sizeof(x))
#define FIN freopen("input.txt","r",stdin)
using namespace std;
int n,k;
int head[MX],rear;
struct Edge
{
    int nxt,to,cap,cost;
} edge[MX*11];
void edge_init()
{
    mem(head,-1);
    rear=0;
}
void edge_add(int a,int b,int cap,int cost)
{
    //cout<<a<<" "<<b<<" "<<cap<<" "<<cost<<endl;
    edge[rear].cost=cost;
    edge[rear].cap=cap;
    edge[rear].nxt=head[a];
    edge[rear].to=b;
    head[a]=rear++;
}
int dis[MX],pre[MX]; //储存前驱顶点
bool vis[MX];
bool spfa(int s, int t)
{
    mem(dis,0x3f);
    mem(vis,0);
    mem(pre,-1);
    deque<int>q;
    q.push_back(s);
    dis[s]=0,vis[s]=1;
    while (!q.empty())
    {
        int u = q.front();
        q.pop_front();
        vis[u] = 0;
        for (int i= head[u]; ~i; i=edge[i].nxt)
        {
            int v=edge[i].to;
            if (edge[i].cap&& dis[v]>dis[u]+edge[i].cost)
            {
                dis[v]=dis[u]+edge[i].cost;
                pre[v] = i;
                if (!vis[v])
                {
                    vis[v]=1;
                    if(!q.empty()&&dis[v]<=dis[q.front()])q.push_front(v);//SLF优化
                    else q.push_back(v);
                }
            }
        }
    }
    if (pre[t]==-1) return 0;
    else return 1;
}
//返回的是最大流， cost存的是最小费用
int MCMF(int s,int t,int &cost)
{
    int flow = 0;
    cost = 0;
    while (spfa(s, t))
    {
        int Min = INF;
        for (int i = pre[t]; i != -1; i = pre[edge[i ^ 1].to])
            if (Min > edge[i].cap) Min = edge[i].cap;
        for (int i = pre[t]; i != -1; i = pre[edge[i ^ 1].to])
            edge[i].cap -= Min,edge[i ^ 1].cap += Min;
        cost += dis[t]* Min;
        flow+=Min;
    }
    return flow;
}
int w[MX][2];
int main()
{
    FIN;
    while(~scanf("%d%d",&n,&k))
    {
        vector<int> arr;
        edge_init();
        for(int i=1; i<=n; i++)
        {
            int a,b;
            scanf("%d%d",&a,&b);
            arr.push_back(w[i][0]=a);
            arr.push_back(w[i][1]=b);
        }
        sort(arr.begin(),arr.end());
        // for(int i=0; i<2*n; i++) cout<<arr[i]<<" ";cout<<endl;
        int cnt=unique(arr.begin(),arr.end())-arr.begin();
        // for(int i=0; i<2*n; i++) cout<<arr[i]<<" ";cout<<endl;
        int s=0,t=cnt+1;
        edge_add(s,1,k,0);
        edge_add(1,s,0,0);
        for(int i=1; i<cnt; i++) edge_add(i,i+1,INF,0),edge_add(i+1,i,0,0);
        edge_add(cnt,t,k,0);
        edge_add(t,cnt,0,0);
        for(int i=1; i<=n; i++)
        {
            int a=lower_bound(arr.begin(),arr.begin()+cnt,w[i][0])-arr.begin()+1,
                b=lower_bound(arr.begin(),arr.begin()+cnt,w[i][1])-arr.begin()+1;
            //cout<<a<<" "<<b<<endl;
            edge_add(a,b,1,-w[i][1]+w[i][0]);
            edge_add(b,a,0,w[i][1]-w[i][0]);
        }

        int cost=0;
        MCMF(s,t,cost);
        printf("%d\n",-cost);
    }
    return 0;
}