LA3709 Hard Life（最大密度子图）

题目链接

题目描述：
给定一个无向图，要求ta的一个子图，使得子图中边数$|E|$与点数$|V|$的比值最大，即最大化：$|E| \over |V|$

分析：
看到了比值形式，可以想到01分数规划
设$F(L)=|E|-L*|V|$
如果$F(L)>0,{|E| \over |V|}>L$，即存在一个答案大于$L$
二分一个答案$L$，现在的问题就是如果选出一个子图得到$F(L)$

把图上的边变成点，作为X部，点作为Y部
源点向边连边，容量为边权（1）
边向ta的两个端点连边，容量为1
点向汇点连边，容量为点权（1）
求出最小割（最大流），那么$F(L)=m-maxflow$，m为边数（边权之和）
如果$F(L)>0$，二分范围left=L，否则right=L

至于构造解
从源点开始，走有残量的路径，访问到的点即为我们选出的点集

#include<cstdio>
#include<cstring>
#include<iostream>
#include<queue>
#include<algorithm>
#include<cmath>

using namespace std;

const double eps=1e-6;
const double INF=1e9;
const int N=1205;
int n,m,s,t,tot=0,st[N];
struct node{
    int x,y,nxt;
    double v;
};
node way[2000010],e[1005];
int deep[N];

void add(int u,int w,double z) {
    tot++;way[tot].x=u;way[tot].y=w;way[tot].v=z;way[tot].nxt=st[u];st[u]=tot;
    tot++;way[tot].x=w;way[tot].y=u;way[tot].v=0;way[tot].nxt=st[w];st[w]=tot;
}

int bfs(int s,int t) {
    memset(deep,-1,sizeof(deep));
    queue<int> Q;
    Q.push(s);
    deep[s]=1;
    while (!Q.empty()) {
        int now=Q.front(); Q.pop();
        for (int i=st[now];i!=-1;i=way[i].nxt)
            if (way[i].v>0&&deep[way[i].y]==-1) {
                deep[way[i].y]=deep[now]+1;
                Q.push(way[i].y);
            }
    }
    return deep[t]!=-1;
}

double dfs(int now,int t,double limit) {
    if (now==t||fabs(limit)<eps) return limit;
    double f,flow=0;
    for (int i=st[now];i!=-1;i=way[i].nxt)
        if (way[i].v>0&&deep[way[i].y]==deep[now]+1&&(f=dfs(way[i].y,t,min(limit,way[i].v)))) {
            flow+=f;
            way[i].v-=f;
            way[i^1].v+=f;
            limit-=f;
            if (fabs(limit)<eps) break;
        }
    return flow;
}

double solve(double L) {
    memset(st,-1,sizeof(st)); tot=-1;
    s=0,t=n+m+1;
    for (int i=1;i<=m;i++) {
        add(s,e[i].v,1.0);
        add(e[i].v,e[i].x,1.0);
        add(e[i].v,e[i].y,1.0);
    }
    for (int i=1;i<=n;i++)
        add(i,t,L);

    double ans=0;
    while (bfs(s,t)) 
        ans+=dfs(s,t,INF);
    return (double)m-ans;
}

int q[N],tou,wei;

void _bfs() {
    tou=wei=0;
    memset(deep,-1,sizeof(deep));
    int cnt=0;
    q[++wei]=s; deep[s]=1;
    while (tou<wei) {
        int now=q[++tou];
        for (int i=st[now];i!=-1;i=way[i].nxt)
            if (way[i].v>0&&deep[way[i].y]==-1) {
                if (way[i].y<=n&&way[i].y>=1) cnt++;
                q[++wei]=way[i].y;
                deep[way[i].y]=1;
            }
    }
    sort(q+1,q+1+wei);
    printf("%d\n",cnt);
    for (int i=2;i<=wei;i++) {
        if (q[i]>n) break;
        printf("%d\n",q[i]);
    }
}

int main() 
{
    int cas=0;
    while (scanf("%d%d",&n,&m)!=EOF) {
        if (cas++) printf("\n");
        if (m==0) {
            printf("1\n1\n");
            continue;
        } 

        for (int i=1;i<=m;i++) scanf("%d%d",&e[i].x,&e[i].y),e[i].v=i+n;
        double l=0,r=n,ans; 
        while (r-l>=eps) {
            double mid=(l+r)/2;
            if (solve(mid)>0) ans=mid,l=mid;
            else r=mid;
        }
        solve(ans);
        _bfs();
    }
    return 0;
}