(最大密度子图)

 

poj 3155 (最大密度子图)

分类： 网络流 2013-09-27 17:19  119人阅读  评论(0)  收藏  举报

ACM 算法 编程 百度 网络流

题意：一个公司有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遍历，最后得出结果。

第一种代码：

 #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);
     }
 }
 int main()
 {
     int i;
     double Left,Right,mid,flow;
     while(scanf("%d%d",&n,&m)!=-1)
     {
         if(m==0){printf("1\n1\n");continue;}
         start=0,end=n+m+1,ans=end+1;
         for(i=0;i<m;i++)
         {
             scanf("%d%d",&P[i].x,&P[i].y);
         }
         Left=0;Right=m;
         while(Right-Left>=1.0/n/n)//胡伯涛的论文给出了证明,不同解之间误差的精度不超过1/(n*n）
         {
             mid=(Left+Right)/2;
             makemap(mid);
             flow=isap();//求出最大权值闭合图
             if(flow<eps)//如果小于0，g值太大
                 Right=mid;
             else Left=mid;
         }
         makemap(Left);//最大密度建图
         isap();
         memset(vis,false,sizeof(vis));
         sum=0;
         dfs1(start);
         printf("%d\n",sum);
         for(i=1;i<=n;i++)
           if(vis[i]==true)//残留网络中源点能到达的点
               printf("%d\n",i);
     }
     return 0;
 }

第二种代码：

 #include<stdio.h>
 #include<string.h>
 const int N=110;
 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(start,i,m*1.0);
         addedge(i,end,m+2*g-dep[i]);
     }
     for(i=0;i<m;i++)
     {
         addedge(P[i].x,P[i].y,1.0);
         addedge(P[i].y,P[i].x,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 maxflow;
 }
 void dfs1(int u)//遍历要选的点
 {
     vis[u]=true;
     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);
     }
 }
 int main()
 {
     int i;
     double Left,Right,mid,hg;
     while(scanf("%d%d",&n,&m)!=-1)
     {
         if(m==0){printf("1\n1\n");continue;}
         start=0,end=n+1,ans=end+1;
         memset(dep,0,sizeof(dep));
         for(i=0;i<m;i++)
         {
             scanf("%d%d",&P[i].x,&P[i].y);
             dep[P[i].x]++;dep[P[i].y]++;
         }
         Left=0;Right=m;
         while(Right-Left>=1.0/n/n)//胡伯涛的论文给出了证明,不同解之间误差的精度不超过1/(n*n）
         {
             mid=(Left+Right)/2;
             makemap(mid);
             hg=isap();
             hg=(1.0*n*m-hg)/2;
             if(hg>eps)
                 Left=mid;
             else Right=mid;
         }
         makemap(Left);//用mid值建图容易wa,因为你此时的mid不一定满足h(mid)>eps,但是Left一定是满足的
         isap();
         memset(vis,false,sizeof(vis));
         sum=0;
         dfs1(0);
         printf("%d\n",sum-1);
         for(i=1;i<=n;i++)
           if(vis[i]==true)
               printf("%d\n",i);
     }
     return 0;
 }