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[N];

int e,head[N];
int dep[N],que[N],cur[N];
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[N];
	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;
}
			

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