poj 3155 Hard Life (最大密度子图)

题意：一个公司有n个人，给出了一些有冲突的人的对数(u,v)，公司决定裁人，那么总裁现在要裁掉冲突率最高的那些人（冲突率=在这些人中存在的冲突数/人数）。就是求出一些点，这些点之间的边数/点数最大。最大密度子图。

思路：胡伯涛的论文《最小割模型在信息学竞赛中的应用》介绍了两种方法：

第一种：转换为最大权闭合图的模型来求解：

设max g = f(x)= |E‘|/|V’| ，找一个子图的边数与点数的比值达到其中的最大，我们通常都是构造一个函数max h（g）= |E'|-g*|V'|,当h(g)为0的时候，g的值即为最优，h（g）>0 时 g<最优值， h(g)<0时，g>最优值；因为如果最大值大于0那么我们就可以继续增加g的值来减小h(g),若最大值都小于0了，那么g不可能增加只可能减少！

观察h（g）,边和点有依赖关系，就边依赖点，边存在的必要条件是点的存在，那么这样以后，如果我们将边看成点，那么这不就符合最大权闭合子图了。现在h（g）的求法就可以通过求新图的最大权闭合子图的值来求解，但是这里有个问题，建图之后你可以发现当求出来的值和h（g）原本应该为值不对应（具体为什么不怎么理解），可以这样理解，当最小的一个g使得h（g）为0的时候该解即为最优解，因为h(g)是以个单调递减函数，就该函数来看只可能存在一个g使得h（g）=0；然而通过求最大权闭合子图是子图权值和为0的有很多中g，当最小的一个g使得h（g）为0之后，如果g继续增大那么虽然通过最大权闭合子图的值求出来依旧为0，但是真正的h（g）< 0 了，所以要使得最优的一个解就是使得最大权闭合子图的权值和为0的最小的一个g值！这样求解之后从源点流到汇点为满流的边即为最大密度子图中的点。

第二种：

源点到各个点连接一条有向边权值为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遍历，最后得出结果。

注意最后用mid值建图容易wa,因为你此时的mid不一定满足h(mid)>eps,但是Left一定是满足的

第一种方法：

好奇怪，用匡斌的isap模板就是一直WA

 #include<stdio.h>
#include<string.h>
const int N=1500;
const double inf=0x3fffffff;
const double eps=1e-8;
int gap[N],dis[N],start,end,ans,sum,head[N],num,dep[N],n,m;
bool vis[N];
struct edge
{
    int st,ed,next;
    double flow;
}e[80*N];
struct node
{
    int x,y;
}P[1100];
void addedge(int x,int y,double w)
{
    e[num].st=x;e[num].ed=y;e[num].flow=w;e[num].next=head[x];head[x]=num++;
    e[num].st=y;e[num].ed=x;e[num].flow=0;e[num].next=head[y];head[y]=num++;
}
void makemap(double g)
{
    int i;
    memset(head,-1,sizeof(head));
    num=0;
    for(i=1;i<=n;i++)
        addedge(i,end,g);
    for(i=0;i<m;i++)
    {
        addedge(n+i+1,P[i].y,inf);
        addedge(n+i+1,P[i].x,inf);
        addedge(start,n+i+1,1.0);
    }
}
double dfs(int u,double minflow)
{
    if(u==end)return minflow;
    int i,v;
    double f,flow=0.0;
    for(i=head[u];i!=-1;i=e[i].next)
    {
        v=e[i].ed;
        if(e[i].flow>0)
        {
            if(dis[v]+1==dis[u])
            {
                f=dfs(v,e[i].flow>minflow-flow?minflow-flow:e[i].flow);
                flow+=f;
                e[i].flow-=f;
                e[i^1].flow+=f;
                if(minflow-flow<=1e-8)return flow;
                if(dis[start]>=ans)return flow;
            }
        }
    }
    if(--gap[dis[u]]==0)
        dis[start]=ans;
    dis[u]++;
    gap[dis[u]]++;
    return flow;
}
double isap()
{
    double maxflow=0.0;
    memset(gap,0,sizeof(gap));
    memset(dis,0,sizeof(dis));
    gap[0]=ans;
    while(dis[start]<ans)
        maxflow+=dfs(start,inf);
    return 1.0*m-maxflow;
}
void dfs1(int u)
{
    vis[u]=true;
    if(u>=1&&u<=n)
    sum++;
    for(int i=head[u];i!=-1;i=e[i].next)
    {
        int v=e[i].ed;
        if(vis[v]==false&&e[i].flow>0)
          dfs1(v);
    }
}
void make_map(double mid)
{
    num = 0;
    memset(head,-1,sizeof(head));
    for(int i = 1; i <= n; i++)
        addedge(i,n+m+1,mid);
    for(int i = 1; i <= m; i++)
    {
        addedge(n+i,P[i].x,inf);
        addedge(n+i,P[i].y,inf);
        addedge(0,n+i,1.0);
    }
}
int main()
{
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    int t,C = 1;
    //scanf("%d",&t);
    while(scanf("%d%d",&n,&m) != EOF)
    {
        for(int i = 1; i <= m; i++)
            scanf("%d%d",&P[i].x,&P[i].y);
        start=0,end=n+m+1,ans=end+1;
        if(m == 0)
        {
            printf("1\n1\n");
            continue;
        }
        double l = 0,r = 1.0*m;
        while(r - l > 1.0/n/n)
        {
            double mid = (l + r) / 2;
            make_map(mid);
            if(isap() > eps)
                l = mid;
            else
                r = mid;
        }
        make_map(l);
        isap();
        memset(vis,0,sizeof(vis));
        sum = 0;
        dfs1(0);
        printf("%d\n",sum);
        for(int i = 1; i <= n; i++)
            if(vis[i])
                printf("%d\n",i);
    }
    return 0;
}

第二种方法：

#include <set>
#include <map>
#include <stack>
#include <queue>
#include <deque>
#include <cmath>
#include <vector>
#include <string>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
#define L(i) i<<1
#define R(i) i<<1|1
#define INF  0x3f3f3f3f
#define pi acos(-1.0)
#define eps 1e-9
#define maxn 100100
#define MOD 1000000007

const int MAXN = 10010;
const int MAXM = 40010;
struct Edge
{
    int to,next;
    double cap,flow;
} edge[MAXM];
int tot,n,m;
int head[MAXN];
int gap[MAXN],dep[MAXN];
int pre[MAXN],cur[MAXN];
int num[1050],mp[110][110];
int vis[110],ans;
void init()
{
    tot = 0;
    memset(head,-1,sizeof(head));
}
void add_edge(int u,int v,double w,double rw = 0)
{
    edge[tot].to = v;
    edge[tot].cap = w;
    edge[tot].flow = 0;
    edge[tot].next = head[u];
    head[u] = tot++;
    edge[tot].to = u;
    edge[tot].cap = rw;
    edge[tot].flow = 0;
    edge[tot].next = head[v];
    head[v] = tot++;
}
double sap(int start,int en,int N)
{
    memset(gap,0,sizeof(gap));
    memset(dep,0,sizeof(dep));
    memcpy(cur,head,sizeof(head));
    int u = start;
    pre[u] = -1;
    gap[0] = N;
    double ans = 0;
    while(dep[start] < N)
    {
        if(u == en)
        {
            double Min = INF;
            for(int i = pre[u]; i != -1; i = pre[edge[i^1].to])
                if(Min > edge[i].cap - edge[i].flow)
                    Min = edge[i].cap - edge[i].flow;
            for(int i = pre[u]; i != -1; i = pre[edge[i^1].to])
            {
                edge[i].flow += Min;
                edge[i^1].flow -= Min;
            }
            u = start;
            ans += Min;
            continue;
        }
        int flag = 0;
        int v;
        for(int i = cur[u]; i != -1; i = edge[i].next)
        {
            v = edge[i].to;
            if(edge[i].cap - edge[i].flow > eps && dep[v]+1 == dep[u])
            {
                flag = 1;
                cur[u] = pre[v] = i;
                break;
            }
        }
        if(flag)
        {
            u = v;
            continue;
        }
        int Min = N;
        for(int i = head[u]; i != -1; i = edge[i].next)
            if(edge[i].cap - edge[i].flow > eps && dep[edge[i].to] < Min)
            {
                Min = dep[edge[i].to];
                cur[u] = i;
            }
        gap[dep[u]]--;
        if(!gap[dep[u]])
            return ans;
        dep[u] = Min + 1;
        gap[dep[u]]++;
        if(u != start)
            u = edge[pre[u]^1].to;
    }
    return ans;
}

void dfs(int u)
{
    vis[u] = 1;
    ans++;
    for(int i = head[u]; i != -1; i = edge[i].next)
    {
        int v = edge[i].to;
        if(!vis[v] && edge[i].cap - edge[i].flow > eps)
            dfs(v);
    }
}
void make_map(double mid)
{
    init();
    for(int i = 1; i <= n; i++)
        for(int j = i + 1; j <= n; j++)
            if(mp[i][j])
            {
                add_edge(i,j,1.0);
                add_edge(j,i,1.0);
            }
    for(int i = 1; i <= n; i++)
    {
        add_edge(0,i,1.0*m);
        add_edge(i,n+1,1.0*m+2*mid-1.0*num[i]);
    }
}
int main()
{
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    int t,C = 1;
    //scanf("%d",&t);
    while(scanf("%d%d",&n,&m) != EOF)
    {
        memset(mp,0,sizeof(mp));
        memset(num,0,sizeof(num));
        for(int i = 1; i <= m; i++)
        {
            int x,y;
            scanf("%d%d",&x,&y);
            mp[x][y] = mp[y][x] = 1;
            num[x]++;
            num[y]++;
        }
        if(m == 0)
        {
            printf("1\n1\n");
            continue;
        }
        double l = 1.0 / n,r = 1.0*m;
        while(r - l > <span style="color:#0820;">1.0/n/n</span>)
        {
            double mid = (l + r) / 2;
            make_map(mid);
            if(1.0*n*m-sap(0,n+1,n+2) > eps)
                l = mid;
            else
                r = mid;
        }
        make_map(l);
        sap(0,n+1,n+2);
        memset(vis,0,sizeof(vis));
        ans = -1;
        dfs(0);
        printf("%d\n",ans);
        for(int i = 1; i <= n; i++)
            if(vis[i])
                printf("%d\n",i);
    }
    return 0;
}