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

最新推荐文章于 2022-07-28 22:37:34 发布

DQSSS

最新推荐文章于 2022-07-28 22:37:34 发布

阅读量1.9k

点赞数 1

分类专栏： ===图论=== 网络流

本文链接：https://blog.csdn.net/LOI_DQS/article/details/50847776

版权

===图论=== 同时被 2 个专栏收录

101 篇文章 0 订阅

订阅专栏

网络流

39 篇文章 0 订阅

订阅专栏

题目描述 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

样例输出 Sample Output

数据范围及提示 Data Size & Hint

若把每个线段看做点，一组不相交的线段集合就可以看做路径。这样问题就转化为选k条路径使得权值和最大，并且路径不能重叠（一个线段只能选一次）。

方法1

按左端点排序所有区间，把每个区间拆分看做两个顶点 <i.a><i.b> <script type="math/tex" id="MathJax-Element-450"> </script>，建立附加源S汇T，以及附加顶点S’。

1、连接S到S’一条容量为K，费用为0的有向边。
2、从S’到每个 <i.a> <script type="math/tex" id="MathJax-Element-451"> </script>连接一条容量为1，费用为0的有向边。
3、从每个 <i.b> <script type="math/tex" id="MathJax-Element-452"> </script>到T连接一条容量为1，费用为0的有向边。
4、从每个顶点 <i.a> <script type="math/tex" id="MathJax-Element-453"> </script>到 <i.b> <script type="math/tex" id="MathJax-Element-454"> </script>连接一条容量为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;
}

DQSSS

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
【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
复制链接

扫一扫