【COGS743】最长k可重区间集问题 最大权不相交路径

题目描述 Description

给定实直线L 上n 个开区间组成的集合I，和一个正整数k，试设计一个算法，从开区

间集合I 中选取出开区间集合S属于I，使得在实直线L 的任何一点x，S 中包含点x 的开区间

个数不超过k，且sum(| z |) z属于S，达到最大。这样的集合S称为开区间集合I的最长k可重区间集。

sum(| z |) z属于S称为最长k可重区间集的长度。

对于给定的开区间集合I和正整数k，计算开区间集合I的最长k可重区间集的长度。

输入描述 Input Description

第1 行有2 个正整数n和k，分别表示开区间的

个数和开区间的可重迭数。接下来的n行，每行有2个整数，表示开区间的左右端点坐标。

输出描述 Output Description

将计算出的最长k可重区间集的长度输出

样例输入 Sample Input

4 2
1 7
6 8
7 10
9 13

样例输出 Sample Output

15

数据范围及提示 Data Size & Hint

若把每个线段看做点，一组不相交的线段集合就可以看做路径。这样问题就转化为选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来说比较好想。拆点（计算选边的价值），容量限制（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可重区间集的长度。

转换思路：端点为点。同样是限制流量。而这次目标针对了【每个点至多出现k次】，而区间则成了一段有价值的点，所以可以端点之间连边来表示。并且这个做法边数更少，更优。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<queue>
using namespace std;

const int INF = 1000000010;
const int SZ = 1000010;

int head[SZ],nxt[SZ],tot = 1;

struct edge{
int f,t,d,c;
}l[SZ];

void build(int f,int t,int d,int c)
{
l[++ tot].t = t;
l[tot].d = d;
l[tot].f = f;
l[tot].c = c;
nxt[tot] = head[f];
head[f] = tot;
}

void insert(int f,int t,int d,int c)
{
build(f,t,d,c); build(t,f,0,-c);
}

int dist[SZ];
deque<int> q;
bool use[SZ];
int pre[SZ];

bool spfa(int s,int e)
{
use[s] = 1;
q.push_front(s);
for(int i = 0;i <= 100000;i ++)
dist[i] = -INF;
dist[s] = 0;
while(q.size())
{
int u = q.front(); q.pop_front();
use[u] = 0;
for(int i = head[u];i;i = nxt[i])
{
int v = l[i].t;
if(l[i].d && dist[v] < dist[u] + l[i].c)
{
dist[v] = dist[u] + l[i].c;
pre[v] = i;
if(!use[v])
{
use[v] = 1;
if(q.empty()) q.push_front(v);
else if(dist[q.front()] > dist[v])
q.push_front(v);
else
q.push_back(v);
}
}
}
}
if(dist[e] == -INF) return false;
return true;
}

int dfs(int s,int e)
{
int x = INF,ans = 0;
for(int i = pre[e];i;i = pre[l[i].f])
x = min(x,l[i].d);
for(int i = pre[e];i;i = pre[l[i].f])
ans += x * l[i].c,l[i].d -= x,l[i ^ 1].d += x;
return ans;
}

int ek(int s,int e)
{
int ans = 0;
while(spfa(s,e)) ans += dfs(s,e);
return ans;
}

struct haha{
int l,r;
}seg[SZ];

bool cmp(haha a,haha b)
{
return a.l < b.l;
}

int main()
{
freopen("interv.in","r",stdin);
freopen("interv.out","w",stdout);
int n,k;
scanf("%d%d",&n,&k);
for(int i = 1;i <= n;i ++)
scanf("%d%d",&seg[i].l,&seg[i].r);
sort(seg + 1,seg + 1 + n,cmp);

int S = n * 2 + 1,S1 = n * 2 + 2,T = n * 2 + 3;

insert(S,S1,k,0);

for(int i = 1;i <= n;i ++)
insert(S1,i,1,0),insert(i + n,T,1,0),insert(i,i + n,1,seg[i].r - seg[i].l);

for(int i = 1;i <= n;i ++)
{
for(int j = i + 1;j <= n;j ++)
{
if(seg[i].r <= seg[j].l)
{
insert(i + n,j,1,0);
}
}
}

printf("%d\n",ek(S,T));
return 0;
}

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<queue>
using namespace std;

const int INF = 1000000010;
const int SZ = 1000010;

int head[SZ],nxt[SZ],tot = 1;

struct edge{
int f,t,d,c;
}l[SZ];

void build(int f,int t,int d,int c)
{
l[++ tot].t = t;
l[tot].d = d;
l[tot].f = f;
l[tot].c = c;
nxt[tot] = head[f];
head[f] = tot;
}

void insert(int f,int t,int d,int c)
{
build(f,t,d,c); build(t,f,0,-c);
}

int dist[SZ];
deque<int> q;
bool use[SZ];
int pre[SZ];

bool spfa(int s,int e)
{
use[s] = 1;
q.push_front(s);
for(int i = 0;i <= 100000;i ++)
dist[i] = -INF;
dist[s] = 0;
while(q.size())
{
int u = q.front(); q.pop_front();
use[u] = 0;
for(int i = head[u];i;i = nxt[i])
{
int v = l[i].t;
if(l[i].d && dist[v] < dist[u] + l[i].c)
{
dist[v] = dist[u] + l[i].c;
pre[v] = i;
if(!use[v])
{
use[v] = 1;
if(q.empty()) q.push_front(v);
else if(dist[q.front()] > dist[v])
q.push_front(v);
else
q.push_back(v);
}
}
}
}
if(dist[e] == -INF) return false;
return true;
}

int dfs(int s,int e)
{
int x = INF,ans = 0;
for(int i = pre[e];i;i = pre[l[i].f])
x = min(x,l[i].d);
for(int i = pre[e];i;i = pre[l[i].f])
ans += x * l[i].c,l[i].d -= x,l[i ^ 1].d += x;
return ans;
}

int ek(int s,int e)
{
int ans = 0;
while(spfa(s,e)) ans += dfs(s,e);
return ans;
}

struct haha{
int l,r;
}seg[SZ];

int lsh[SZ];

int main()
{
freopen("interv.in","r",stdin);
freopen("interv.out","w",stdout);
int n,k;
scanf("%d%d",&n,&k);
for(int i = 1;i <= n;i ++)
{
scanf("%d%d",&seg[i].l,&seg[i].r);
lsh[++ lsh[0]] = seg[i].l;
lsh[++ lsh[0]] = seg[i].r;
}
sort(lsh + 1,lsh + 1 + lsh[0]);
int m = unique(lsh + 1,lsh + 1 + lsh[0]) - lsh - 1;

int S = m + 1,T = m + 2;

insert(S,1,k,0); insert(m,T,k,0);

for(int i = 1;i < m;i ++)
insert(i,i + 1,INF,0);

for(int i = 1;i <= n;i ++)
{
int x = lower_bound(lsh + 1,lsh + 1 + m,seg[i].l) - lsh;
int y = lower_bound(lsh + 1,lsh + 1 + m,seg[i].r) - lsh;
insert(x,y,1,seg[i].r - seg[i].l);
}

printf("%d\n",ek(S,T));
return 0;
}