pku 3155 Hard Life 最大密集子图

http://poj.org/problem?id=3155

题意：

给定一个无向图，求该图的一个子图使得该子图中边/点的权值最大；

思路：

证明看论文：http://wenku.baidu.com/view/986baf00b52acfc789ebc9a9.html

建图方法：

把原图中的无向边转换成两条有向边，容量为1；

设一源点，连接所有点，容量为U

设一汇点，所有点连接汇点，容量为 U+2g-du

二分枚举最大密度g，其中du为u的度。

U一般取边数即可。

//#pragma comment(linker,"/STACK:327680000,327680000")

#include <iostream>

#include <cstdio>

#include <cmath>

#include <vector>

#include <cstring>

#include <algorithm>

#include <string>

#include <set>

#include <functional>

#include <numeric>

#include <sstream>

#include <stack>

#include <map>

#include <queue>



#define CL(arr, val)    memset(arr, val, sizeof(arr))



#define lc l,m,rt<<1

#define rc m + 1,r,rt<<1|1

#define pi acos(-1.0)

#define ll long long

#define L(x)    (x) << 1

#define R(x)    (x) << 1 | 1

#define MID(l, r)   (l + r) >> 1

#define Min(x, y)   (x) < (y) ? (x) : (y)

#define Max(x, y)   (x) < (y) ? (y) : (x)

#define E(x)        (1 << (x))

#define iabs(x)     (x) < 0 ? -(x) : (x)

#define OUT(x)  printf("%I64d\n", x)

#define lowbit(x)   (x)&(-x)

#define Read()  freopen("din.txt", "r", stdin)

#define Write() freopen("dout.txt", "w", stdout);





#define M 1000007

#define N 1107



using namespace std;



const double inf = ~0u;

const double eps = 1e-6;

double lim;



struct node

{

    int v;

    double w;

    int next;

}g[M];

int head[N],ct;

int q[N*100];



int level[N];

bool vt[N];



struct t_node

{

    int u,v;

}t_g[N];



int path[N],len;

int du[N];

int n,m;



void add(int u,int v,double w)

{

    g[ct].v = v;

    g[ct].w = w;

    g[ct].next = head[u];

    head[u] = ct++;



    g[ct].v = u;

    g[ct].w = 0;

    g[ct].next = head[v];

    head[v] = ct++;

}

bool layer(int s,int e){

    int i;

    CL(level,-1);

    level[s] = 0;

    int l,r;

    l = r = 0;

    q[r] = s;

    while (l <= r){

        int u = q[l++];

        for (i = head[u]; i != -1; i = g[i].next){

            int v = g[i].v;

            if (level[v] == -1 && g[i].w > eps){

                level[v] = level[u] + 1;

                q[++r] = v;

                if (v == e) return true;

            }

        }

    }

    return false;

}

double find(int s,int e){

    int i;

    double ans = 0;

    int top = 1;



    while (top){

        int u = (top == 1 ? s : g[q[top - 1]].v);//如果没有变肯定是起点，否则就是上一个边终点



        if (u == e){

            double MIN = inf;

            int pos;

            //找出最小流量

            for (i = 1; i < top; ++i){

                int tp = q[i];//注意这里取边的编号

                if (g[tp].w < MIN){

                    MIN = g[tp].w;

                    pos = i;

                }

            }

            //更新容量

            for (i = 1; i < top; ++i){

                int tp = q[i];//注意这里取边的编号

                g[tp].w -= MIN;

                g[tp^1].w += MIN;

            }

            ans += MIN;

            top = pos;

        }

        else{//找可行流

            for (i = head[u]; i != -1; i = g[i].next){

                int v = g[i].v;

                if (g[i].w > eps && level[v] == level[u] + 1){

                    q[top++] = i;

                    break;

                 }

            }

            if (i == -1){//如果u没有可走的子节点

                top--;

                level[u] = -1;

            }

        }

    }

    return ans;

}

double dinic(int s,int e,double mid)

{

    int i;

    //建图是关键

    CL(head,-1); ct = 0;

    for (i =  1; i <= m; ++i)

    {

        int u = t_g[i].u;

        int v = t_g[i].v;

        add(u,v,1.0); add(v,u,1.0);

    }

    for (i = 1; i <= n; ++i)

    {

        add(s,i,m);

        add(i,e,1.0*m + 2*mid - du[i]);

    }

    //求最小割

    double ans = 0;

    while (layer(s,e)) ans += find(s,e);

    return ans;

}

void dfs(int s)

{

    vt[s] = true;

    for (int i = head[s]; i != -1; i = g[i].next)

    {

        int v = g[i].v;

        double w = g[i].w;

        if (!vt[v] &&  w > eps)

        {

            path[len++] = v;

            dfs(v);

        }

    }

}

int main()

{

    //Read();

    int i;

    while (~scanf("%d%d",&n,&m))

    {

        if (m == 0)

        {

            printf("1\n1\n");

            continue;

        }

        CL(du,0);

        for (i = 1; i <= m; ++i)

        {

            scanf("%d%d",&t_g[i].u,&t_g[i].v);

            du[t_g[i].u]++;

            du[t_g[i].v]++;

        }

        double l = 1.0/n;

        double r = m*1.0;

        double mid = 0;

        int s = 0;

        int e = n + 1;

        lim = 1.0/(n*n);

        while (r - l > lim)//证明有：任意两个最大密度子图的差值不会超过1/(n*n)

        {

            mid = (l + r)/2;

            double tmp = dinic(s,e,mid);

            double ans = (m*n - tmp)/2.0;//得到值

            if (ans > eps) l = mid;

            else r = mid;

        }

        dinic(s,e,l);

        CL(vt,false);

        len = 0;

        dfs(s);

        sort(path,path + len);

        printf("%d\n",len);

        for (i = 0; i < len; ++i) printf("%d\n",path[i]);

    }

    return 0;

}