P3357 最长k可重线段集问题

问题描述

• 给定平面上n个开线段，从中选取若干线段，使得在任意直线x=p与这些线段相交的个数不超过k的前提下所选线段的长度和最大，线段长度定义为线段两端点的欧几里得距离下取整。

问题分析

• 乍一看与最长k可重区间集问题很像，转换成在线段上点的覆盖问题，对每一个线段进行离散化，运用“串并联”的思想建图：

  • 将线段投影到x轴上左端点向右端点脸容量为1，权值为长度的边，限制每个线段只能选一次；
  • 源点1向所有左端点连容量为1，权值为0的边，所有右端点向汇点连权值0，流量为1 的边，源点2向源点1连权值0，流量k的边，限制最多覆盖k次；
  • 最后对与每一对投影到x轴上不相交的线段r[i]<=l[j]，r[i]向l[j]连容量为1，权值为0的边组成“串联电路”；

• 考虑这样做有没有问题：将线段投影到x轴之后与最长k可重区间集问题的不同在于权值的计算与覆盖的等价性上，由于本题中存在垂直于x轴的线段，投影在x轴上为（xi,xi）,这样的开线段无“覆盖”意义但有权值贡献，显然，按照原方法建图会出现自正环！

• 或许需要换一个离散的方法，使得垂直于x轴的线段能离散成两个点且其它线段间的关系依旧能得到准确体现，下面展示朝这个方向的一些思考:

  • 由于是开线段，端点判断时等号要保留，因此可以考虑想个办法使得垂直于x轴的线段投影到x轴为相邻的两个整数点：r[i]-l[i]=1；
  • 如果单纯的给这类线段的右端点+1，显然会破坏与其它线段的覆盖关系，如果能将离散后点与点的间隔放大一倍，这样在x轴上不重叠的点的最小距离为2，有了这个距离我们就可以将垂直于x轴的线段与不垂直的线段离散之后“错开”，且不破坏其它覆盖关系。

• 具体离散方法为：垂直于x轴的线段离散为2x,2x+1,其余线段离散为2xi+1,2xj,由于离散后点的距离为原来的两倍，因此原来的覆盖关系不受影响，如图：
  

代码

#include <iostream>
#include <cstdio>
#include <cstring>
#include <map>
#include <queue>
#include <algorithm>
#include <cmath>
using namespace std;
const int maxn=1505,maxm=500005,inf=0x7f7f7f7f7f;
int n,k,num=1,last[maxn],cur[maxn],vis[maxn],st=1500,cnt=1,inq[maxn];
long long l[505],r[505],y,yy,x,xx,ans,flow,d[maxn];
map<long long,int>p;
struct edge{
    int v,next,w,f;
}e[maxm];
inline void add(int u,int v,int w,int f)
{
    e[++cnt].v=v;
    e[cnt].f=f;
    e[cnt].w=w;
    e[cnt].next=last[u];
    last[u]=cnt;
    e[++cnt].v=u;
    e[cnt].f=0;
    e[cnt].next=last[v];
    e[cnt].w=-w;
    last[v]=cnt;
}
bool spfa()
{
    queue<int>q;
    memset(inq,0,sizeof(inq));
    for(int i=1;i<=st;i++) d[i]=inf;
    d[0]=0;
    q.push(0);
    while(!q.empty())
    {
        int u=q.front();q.pop();
        inq[u]=0;
        for(int i=last[u];i;i=e[i].next)
        {
            int v=e[i].v,w=e[i].w,f=e[i].f;
            if(d[v]>d[u]+w&&f)
            {
                d[v]=d[u]+w;
                if(!inq[v])
                {
                    inq[v]=1;
                    q.push(v);
                }
            }
        }
    }
    return d[st]!=inf;
}
int dfs(int u,int dis)
{
    vis[u]=1;
    if(u==st||!dis) return dis;
    for(int i=cur[u];i;i=e[i].next)
    {
        cur[u]=e[i].next;
        int v=e[i].v,w=e[i].w,f=e[i].f;
        if(d[v]==d[u]+w&&f&&!vis[v])
        {
            vis[v]=1;
            int di=dfs(v,min(dis,f));
            if(di>0)
            {
                e[i].f-=di;
                e[i^1].f+=di;
                return di;
            }
        }
    }
    return 0;
}
bool dinic()
{
    while(spfa())
    {
        for(int i=0;i<=st;i++)
        cur[i]=last[i];
        memset(vis,0,sizeof(vis));
        while(int ml=dfs(0,inf))
        {

            ans+=d[st];
            flow+=ml;
            memset(vis,0,sizeof(vis));
        }
    }
    if(flow!=n) return 0;
    return 1;
}
int main()
{
    cin>>n>>k;
    add(0,1,0,k);
    for(int i=1;i<=n;i++)
    {
        cin>>x>>y>>xx>>yy;
        l[i]=x;r[i]=xx;
        if(l[i]>r[i])
        swap(l[i],r[i]);
        l[i]=l[i]*2;
        r[i]=r[i]*2;
        if(l[i]==r[i])
        r[i]++;
        else
        l[i]++;
        if(!p[l[i]])
        p[l[i]]=++num;
        if(!p[r[i]])
        p[r[i]]=++num;
        add(1,p[l[i]],0,1);
        add(p[r[i]],st,0,1);
        add(p[l[i]],p[r[i]],-sqrt((xx-x)*(xx-x)+(yy-y)*(yy-y)),1);
    }
    for(int i=1;i<=n;i++)
    for(int j=1;j<=n;j++)
    if(r[i]<=l[j])
    add(p[r[i]],p[l[j]],0,1);
    dinic();
    cout<<-ans;
    return 0;
}