最大密集字图--参考《胡伯涛的论文》！poj 3155

论文连接

/*
题意：求出图中一个子图，子图中边数/子图数 最大！

源点到各个点连接一条有向边权值为U,各个点到汇点连接一条边权值为U+2*g-d，
原来有关系的点连接两条有向边（u,v），（v,u）权值为1（U可以取m，U的目的是用来使得2*g-d的值始终为正），
这样以后求最小割，那么h（g）= （U*n-mincut）/2;二分找到最优值即为mid ，
但是如果要求图中的点则需要用left来从新图求最大流之后然后从源点开始dfs遍历，最后得出结果。
*/
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#include<iostream>
#include<algorithm>
#include<stack>
#include<queue>
#include<vector>
#include<set>
#include<map>
#include<string>
using namespace std;
typedef long long ll;
typedef pair<int,int>P;
const int INF=0x3f3f3f3f;
const ll INFF=0x3f3f3f3f3f3f3f3f;
const double pi=acos(-1.0);
const double epss=1e-9;
int level[105],iter[105];
struct node{int x,y;double c;int rev;};
vector<node>vec[105];
void add_edge(int x,int y,double c)
{
    node p1,p2;p1.y=y,p1.c=c,p1.rev=vec[y].size();vec[x].push_back(p1);
    p2.y=x,p2.c=0,p2.rev=vec[x].size()-1;vec[y].push_back(p2);
}
void bfs(int s)
{
    memset(level,-1,sizeof(level));
    queue<int>q;level[s]=0;q.push(s);
    while(!q.empty())
    {
        int v=q.front();
        q.pop();
        for(int i=0;i<vec[v].size();i++)
        {
            node p=vec[v][i];
            if(p.c>0&&level[p.y]<0)
            {
                level[p.y]=level[v]+1;
                q.push(p.y);
            }
        }
    }
}

double dfs(int v,int t,double f)
{
    if(v==t)
        return f;
    for(int &i=iter[v];i<vec[v].size();i++)
    {
        node &p=vec[v][i];
        if(p.c>0&&level[v]<level[p.y])
        {
            double d=dfs(p.y,t,min(f,p.c));
            if(d>0)
            {
                p.c-=d;
                vec[p.y][p.rev].c+=d;
                return d;
            }
        }
    }
    return 0;
}

double max_flow(int s,int t)
{
    double ans=0;
    for(;;)
    {
        bfs(s);
        if(level[t]<0)
            return ans;
        memset(iter,0,sizeof(iter));
        double f;
        while((f=dfs(s,t,INF))>0)
            ans+=f;
    }
}
struct node2{int x,y;}p[1010];
int s,t,n,m;
int degree[105];
void build_edge(double mid)
{
    for(int i=0;i<=n+1;i++)
        vec[i].clear();
    for(int i=1;i<=n;i++)
    {
        add_edge(s,i,m);
        add_edge(i,t,m+2*mid-degree[i]);
    }
    for(int i=0;i<m;i++)
    {
        add_edge(p[i].x,p[i].y,1.0);
        add_edge(p[i].y,p[i].x,1.0);
    }
}
bool vis[105];int sum=0;
double eps;
void dfs_vis(int u)
{
    sum++;
    vis[u]=1;
    for(int i=0;i<vec[u].size();i++)
    {
        node &e=vec[u][i];
        if(e.c>epss&&!vis[e.y])
            dfs_vis(e.y);
    }
}
int main()
{
    scanf("%d%d",&n,&m);
    if(m==0)
    {
        printf("1\n1\n");
        return 0;
    }
    s=0,t=n+1;
    for(int i=0;i<m;i++)
    {
        scanf("%d%d",&p[i].x,&p[i].y)
        degree[p[i].x]++;degree[p[i].y]++;
    }
    double l=0,r=m;
    eps=1.0/(n*n);//胡伯涛的论文给出了证明,不同解之间误差的精度不超过1/(n*n）  
    while(r-l>=eps)
    {
        double mid=(l+r)/2;
        build_edge(mid);
        if((n*m-max_flow(s,t))/2>=epss)
            l=mid;
        else
            r=mid;
    }
    build_edge(l);//用mid值建图容易wa,因为你此时的mid不一定满足h(mid)>eps,但是Left一定是满足的  
    max_flow(s,t);
    dfs_vis(0);
    printf("%d\n",sum-1);
    for(int i=1;i<=n;i++)
        if(vis[i])
            printf("%d\n",i);
    return 0;
}