poj 3155(Hard Life)分数规划/最大密度子图

题目链接：http://poj.org/problem?id=3155

题意简述：一个公司有n个人，给出了一些有冲突的人的对数(u,v)，所有为了公司更好的发展，公司的总裁决定裁人，那么总裁现在裁要裁掉冲突率最高的哪些（冲突率=人数/在这些人中存在的冲突数） （题意有所扭曲，但也就是这个意思）

分析： 很明显的一个求最大密度子图的题目，求最大密度子图的方法有两种不同的模型可以求解，一种是采用了转换为最大权闭合图的模型来求解，而另一种则是通过补集转换的思想来求解，现在就最大权闭合图的模型来谈论以下：设max g = f(x)= |E‘|/|V’| ，找一个子图的边数与点数的比值达到其中的最大，我们通常都是构造一个函数max h（g）= |E'|-g*|V'|,当h(g)为0的时候，g的值即为最优（证明见Amber论文），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遍历，最后得出结果

代码如下（第二种模型的实现）

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const double inf = 0xffffffff;
const int N = 110;
const int E = 30000;
const double eps=1e-8;
struct node1
{
int x, y;
}a[1010];
int ans;
bool vis
;

int e,head
;
int dep
,que
,cur
;
struct node
{
int x,y;
int nxt;
double c;
}edge[E];
void addedge(int u,int v,double c)
{
edge[e].x=u;
edge[e].y=v;
edge[e].nxt=head[u];
edge[e].c=c;
head[u]=e++;

edge[e].x=v;
edge[e].y=u;
edge[e].nxt=head[v];
edge[e].c=0;
head[v]=e++;
}

double maxflow(int s,int t)
{
int i,j,k,front,rear,top;double min,res=0;
while(1)
{
memset(dep,-1,sizeof(dep));
front=0;
rear=0;
que[rear++]=s;
dep[s]=0;
while(front!=rear)
{
i=que[front++];
for(j=head[i];j!=-1;j=edge[j].nxt)
if(edge[j].c>eps&&dep[edge[j].y]==-1)
{
dep[edge[j].y]=dep[i]+1;
que[rear++]=edge[j].y;

}
}
if(dep[t]==-1)
break;
memcpy(cur,head,sizeof(head));
for(i=s,top=0;;)
{
if(i==t)
{
min=inf;
for(k=0;k<top;k++)
if(min>edge[que[k]].c)
{
min=edge[que[k]].c;
front=k;
}
for(k=0;k<top;k++)
{
edge[que[k]].c-=min;
edge[que[k]^1].c+=min;
}
res+=min;
i=edge[que[top=front]].x;

}
for(j=cur[i];cur[i]!=-1;j=cur[i]=edge[cur[i]].nxt)
if(dep[edge[j].y]==dep[i]+1&&edge[j].c>eps)
break;
if(cur[i]!=-1)
{
que[top++]=cur[i];
i=edge[cur[i]].y;
}
else
{
if(top==0)
break;
dep[i]=-1;
i=edge[que[--top]].x;
}
}
}
return res;
}

void dfs(int u)
{
vis[u]=true;
ans++;
for(int i=head[u];i!=-1;i=edge[i].nxt)
{
int y = edge[i].y;
if(edge[i].c>eps&&vis[y]==false)
dfs(y);
}
}
int main ()
{
int n, m;
int d
;
int i,x,y;
while(scanf("%d%d",&n,&m)!=EOF)
{
memset(d,0,sizeof(d));
for(i=0;i<m;i++)
{
scanf("%d%d",&x,&y);
a[i].x=x;
a[i].y=y;
d[x]++;
d[y]++;
}
if(m==0)
{printf("1\n1\n");continue;}
double left = 0;
double right = 1.0*m;
while(right-left>=1.0/n/n)
{
double mid = (left+right)/2;
memset(head,-1,sizeof(head));
e = 0;
for(i=0;i<m;i++)
{
addedge(a[i].x,a[i].y,1);
addedge(a[i].y,a[i].x,1);
}
for(i=1;i<=n;i++)
{
addedge(0,i,1.0*m);
addedge(i,n+1,m+2*mid-1.0*d[i]);
}
double flow=maxflow(0,n+1);
flow = (1.0*m*n-flow)/2.0;
if(flow>eps)
left=mid;
else right = mid;
}
memset(head,-1,sizeof(head));
e = 0;
for(i=0;i<m;i++)
{
addedge(a[i].x,a[i].y,1);
addedge(a[i].y,a[i].x,1);
}
for(i=1;i<=n;i++)
{
addedge(0,i,1.0*m);
addedge(i,n+1,m+2*left-1.0*d[i]);
}
maxflow(0,n+1);
ans = 0;
memset(vis,0,sizeof(vis));
dfs(0);
printf("%d\n",ans-1);
for(i=1;i<=n;i++)
if(vis[i])
printf("%d\n",i);
}
return 0;
}

代码如下（用第二种模型实现）：