[POJ3155]Hard Life（01分数规划）

题目描述

传送门
题意：一张图，选出一个子图，满足边数/点数最大

题解

最大密度子图问题…
算法一
二分g，然后点权变成-g，边权变成1，求一个最大的子图
可以发现边权为正，点权为负，所以说会尽量多选边，那么我们说选一条边就一定会选两个点就没有什么问题了（按理来说应该是选了两个点就一定要选某条边）
这就是一个典型的最大权闭合子图问题了…建图之后跑最小割就行了
算法二（对算法一的改进算法）
有的时候算法一的边和点太多…
设每一个点的度为$d_i$，然后将原问题取相反数了之后变成了求最小
假设我们求出了一个点集，需要计算的边就是所有与这个点集相关的边-只有一个端点在点集里的边
只有一个端点在点集里的边实际上就是将点集与其它分开的一个割，所以说这个点集也是一个割集
现在可以转化成这样一个问题：某一个点不选代价是0，选了代价是$2g-d_i$，然后如果两个点一个选了一个没选并且中间有边的话这条边需要割掉，也就是花费1的代价，然后选一些点使代价最小
这样就是一个最小割的模型了：原图中的边x->y在新图中连边x->y,y->x,1，对于原图中的每一个点s->i,U，i->t,U+2g-di（U是一个大数，保证边权不为负），然后判断(U*n-c)/2和0的关系即可（取相反数了之后再反回去）

推荐看看胡伯涛的论文

代码

#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<queue>
using namespace std;
#define N 10005

const double eps=1e-10;
int dcmp(double x)
{
    if (x<=eps&&x>=-eps) return 0;
    return (x>0)?1:-1;
}
int n,m,s,t,x[N],y[N];
int tot,point[N],nxt[N],v[N];double remain[N];
int deep[N],last[N],cur[N],num[N],ans[N];
double d[N],maxflow,ave,U;
bool vis[N];
queue <int> q;

void addedge(int x,int y,double cap)
{
    ++tot; nxt[tot]=point[x]; point[x]=tot; v[tot]=y; remain[tot]=cap;
    ++tot; nxt[tot]=point[y]; point[y]=tot; v[tot]=x; remain[tot]=0;
}
void bfs(int t)
{
    for (int i=1;i<=t;++i) deep[i]=t;
    deep[t]=0;
    for (int i=1;i<=t;++i) cur[i]=point[i];
    while (!q.empty()) q.pop();
    q.push(t);
    while (!q.empty())
    {
        int now=q.front();q.pop();
        for (int i=point[now];i!=-1;i=nxt[i])
            if (deep[v[i]]==t&&dcmp(remain[i^1]))
            {
                deep[v[i]]=deep[now]+1;
                q.push(v[i]);
            }
    }
}
double addflow(int s,int t)
{
    int now=t;
    double ans=1e10;
    while (now!=s)
    {
        ans=min(ans,remain[last[now]]);
        now=v[last[now]^1];
    }
    now=t;
    while (now!=s)
    {
        remain[last[now]]-=ans;
        remain[last[now]^1]+=ans;
        now=v[last[now]^1];
    }
    return ans;
}
void isap(int s,int t)
{
    bfs(t);
    for (int i=1;i<=t;++i) ++num[deep[i]];

    int now=s;
    while (deep[s]<t)
    {
        if (now==t)
        {
            maxflow+=addflow(s,t);
            now=s;
        }

        bool has_find=0;
        for (int i=point[now];i!=-1;i=nxt[i])
            if (deep[v[i]]+1==deep[now]&&dcmp(remain[i]))
            {
                has_find=1;
                cur[now]=i;
                last[v[i]]=i;
                now=v[i];
                break;
            }

        if (!has_find)
        {
            int minn=t-1;
            for (int i=point[now];i!=-1;i=nxt[i])
                if (dcmp(remain[i])) minn=min(minn,deep[v[i]]);
            if (!(--num[deep[now]])) break;
            ++num[deep[now]=minn+1];
            cur[now]=point[now];
            if (now!=s) now=v[last[now]^1];
        }
    }
}
bool check(double g)
{
    tot=-1;memset(point,-1,sizeof(point));
    memset(num,0,sizeof(num));
    for (int i=1;i<=m;++i) addedge(x[i],y[i],1.0),addedge(y[i],x[i],1.0);
    for (int i=1;i<=n;++i) addedge(s,i,U),addedge(i,t,U+2*g-d[i]);
    maxflow=0;isap(s,t);
    return dcmp(U*(double)n-maxflow)>0;
}
void find()
{
    double l=0,r=m+0.0,mid;
    while (r-l>=1.0/n/n)
    {
        mid=(l+r)/2.0;
        if (check(mid)) ave=l=mid;
        else r=mid;
    }
}
void dfs(int x)
{
    vis[x]=1;
    for (int i=point[x];i;i=nxt[i])
        if (!vis[v[i]]&&dcmp(remain[i]))
            dfs(v[i]);
}
int main()
{
    scanf("%d%d",&n,&m);U=m+0.0;
    if (m==0) {puts("1\n1\n");return 0;}
    s=n+1,t=s+1;
    for (int i=1;i<=m;++i) scanf("%d%d",&x[i],&y[i]),d[x[i]]+=1.0,d[y[i]]+=1.0;
    find();
    check(ave);
    dfs(s);
    for (int i=1;i<=n;++i)
        if (vis[i]) ans[++ans[0]]=i;
    printf("%d\n",ans[0]);
    for (int i=1;i<=ans[0];++i) printf("%d\n",ans[i]);
}