poj3155 Hard Life

题目大意：给一个无向图，求此图的最大密度子图。

输入：n，m，表示有n个点（1 -- n编号），接m行，每行u v，表示u到v有一条无向边。

网上各种传说这是一种分数规划的东西，然后我也不了解，搜了很多资料，也没有人给了很好的解释。貌似胡伯涛的一篇文章里提到了这样的算法，但是里面的证明各种看不懂。好吧，看不懂我就只有另寻他法了。

 乍一看，毫无策略。方案核心是要找答案，那就直接枚举答案测试好了。题目要找最大密度**，也即（选中的边数/与这些边边有关的点数）。那就二分枚举这个最大密度吧！！！

假设答案是k，任意所选边集为E，与E对应的点集V，即有max{|E|/|V|} == k，也就是说|E|/|V| <= k 也等价于 |E|-|V|*k <= 0。

现在测试x是不是答案，若x>k，则不管怎么选都会有 |E|-|V|*k < 0； 若 x < k 则 能找到E使得 |E|-|V|*k > 0。

现在我们枚举要选中的边，假设选中边uv，那么必选点u、v。若H(x)=E(x)-V(x)*k，选中边uv的结果是H(x)=H(x)+1,选中点u、v的结果是H(x)=H(x)-1-1。

由于所有边都最终指向两个点，而点是截止的，这不就是最大权闭合子图吗？？？！！！

构图是不是就很水了: C(S,UV)=1, C(UV,V)=1, C(UV,U)=1, C(U,T)=x。然后最大流求出,H(x)=m-maxF();

注意一个小小的坑，用最大流求最大权闭合子图时，H(x) < 0是体现不出来的。所以祝你好运了。贴个代码……

#include <iostream>
#include <cstring>
#include <cstdio>
#include <queue>
using namespace std;
#define maxn 150
const int maxe = 1001000;
const double maxf = 1e10;
#define zero 1e-8
struct edge{
    int u,v; double c;
    edge(int e1=0,int e2=0,double e3=0){ u=e1,v=e2; c=e3; }
}e[maxe];
int ec;
int head[maxn];
int next[maxe];
void addedge(int u,int v,double c){
    e[ec]=edge(u,v,c);
    next[ec]=head[u]; head[u]=ec++;
    e[ec]=edge(v,u,0);
    next[ec]=head[v]; head[v]=ec++;
}
//***********************************//
int source,sink,maxdep;
int dep[maxn],gap[maxn];
void setGD(){
     for(int i=0;i<=maxdep;i++) dep[i] = maxdep; dep[sink] = 0;
     int u,v;
     queue<int> que;
     que.push(sink);
     while(!que.empty()){
           u = que.front(); que.pop();
           for(int i=head[u];i!=-1;i=next[i]){
                 v = e[i].v; //if(v > maxdep) continue;
                 if(dep[v] < maxdep) continue; //'被访问过'
                 dep[v] = dep[u]+1;
                 que.push(v);
           }
     }
     memset(gap,0,sizeof(gap));
     for(int i=0;i<=maxdep;i++) gap[dep[i]]++;
}
double maxF(){
    setGD();
    int u=source,i;
    int cur[maxn],trace[maxn],top=0;
    for(int i=0;i<=maxdep;i++) cur[i] = head[i];
    double flow=0;
    while(dep[source] <= maxdep){
        if(u == sink){
             double tf = maxf; int ins;
             for(i=0;i<top;i++) //找瓶颈边
                if(tf - e[trace[i]].c > 0)
                      tf = e[trace[i]].c, ins = i;
             for(i=0;i<top;i++){
                e[trace[i]].c -= tf;
                e[trace[i]^1].c += tf;
             }
             flow += tf;
             u = e[trace[ins]].u, top = ins;
        }
        if(u != sink && gap[dep[u]-1]==0) break;
        for(i=cur[u];i!=-1;i=next[i])
             if(e[i].c > zero && dep[u] == dep[e[i].v] + 1)
                       break;
        if(i != -1) {
             trace[top++] = i;
             cur[u] = i;
             u = e[i].v;
        }
        else {
             int mindep = maxdep;
             for(i=head[u];i!=-1;i=next[i]){
                 if(e[i].c > zero && dep[e[i].v] < mindep)
                           mindep = dep[e[i].v], cur[u] = i;
             }
             gap[dep[u]]--;
             dep[u] =  mindep + 1;
             gap[dep[u]]++;
             if(u != source)
                u = e[trace[--top]].u;
        }
    }
    return flow;
}
//**********************************//
void initial(){
     ec = 0;
     memset(head,-1,sizeof(head));
     //initial source ,sink and maxdep;
}
int uu[1010],vv[1010],degree[maxn];
double most;
void mapping(int n,int m,double k){
    initial();
    for(int i=1;i<=n;i++) {
        addedge(source,i,most);
        addedge(i,sink,most+2*k-degree[i]);
    }
    for(int i=1;i<=m;i++) {
        addedge(vv[i],uu[i],1);
        addedge(uu[i],vv[i],1);
    }
}
bool visited[maxn];
void search(int u){
    visited[u]=1;
    for(int i=head[u];i>=0;i=next[i])
    if(e[i].c > zero && !visited[e[i].v])
        search(e[i].v);
}
int main()
{
    int n,m;
    while(scanf("%d%d",&n,&m) != EOF){
        memset(degree,0,sizeof(degree));
        for(int i=1;i<=m;i++)
            scanf("%d%d",&uu[i],&vv[i]), degree[uu[i]]++, degree[vv[i]]++;
        if(m == 0){
            printf("1
1
");
            continue;
        }
        source=0;
        sink=n+1;
        maxdep=sink+1;
        most=m+n;
        double left=0,right=m+n,eps=1e-5,mid;
        while(right-left > eps){
            mid = (left+right)*0.5;
            mapping(n,m,mid);
            double hx=(n*most-maxF())*0.5;
            if(hx>1e-5) left=mid;
            else right=mid;
        }
        mid = left; //mid重新赋值，否则有可能WA掉
        mapping(n,m,mid);
        double flow=maxF();
        //printf("mid = %.10f
",mid);
        memset(visited,0,sizeof(visited));
        search(source);
        int ret=0;
        for(int i=1;i<=n;i++)
        if(visited[i]) ret++;
        printf("%d
",ret);
        for(int i=1;i<=n;i++)
        if(visited[i])
            printf("%d
",i);
    }
    return 0;
}