Bzoj1312 / POJ3155 Neerc2006 Hard Life

Time Limit: 10 Sec  Memory Limit: 162 MB
Submit: 459  Solved: 114

Description

在一家公司中，人事部经理与业务部经理不和。一次，总经理要求人事部从公司的职员中挑选出一些来帮助业务部经理完成一项任务。人事部经理发现，在公司的所有职员中，有一些人相处得很不好。如果把他们同时放在一个工作小组中，他们将会给主管带来不小的麻烦。人事部经理还知道，在一个工作小组中，主管人员的麻烦程度可以认为是(带来麻烦的人的对数/总人数) 。于是，人事部经理决定选取这样的一些人，使得业务部经理的麻烦度最大。你的任务是帮助人事部经理达到他的目的。 在这样的一个公司中，保证公司的人数小于100 人，带来麻烦的员工不会多于1000 对。

Input

第一行给出N,M代表共有N个人,M对人之间有怨念 下面M行，每行两个数，代表这两个人有怨念

Output

输出最多能找出多少个人，人数>=1

Sample Input

5 6
1 5
5 4
4 2
2 5
1 2
3 1

Sample Output

4

HINT

Source

 

图论 最大密度子图 01分数规划 网络流

将人抽象成点，关系抽象成边，则“带来麻烦的人的对数/总人数”就是一个子图中边数/点数，这玩意儿叫做图的密度。

原题POJ3155 要求输出密度最大时的任一方案

这里要求输出密度最大时最多能选出多少个人。

 

设密度r=边数/点数，显然是一个01分数规划问题。

解法1：

　　将每条边看做一个点，对于原图中的一条无向边<u,v>，从代表<u,v>的点向点u和点v各连一条边，容量为INF；

　　从S向<u,v>连边，容量为1

　　从u和v向T连边，容量为r

　　↑原问题转化成了最大权闭合子图问题。

 

解法2：

　　证明见胡伯涛《最小割模型在信息学竞赛中的应用》

　　U=m

　　从S向u连边，容量为U

　　从v向T连边，容量为U+2*r-deg[v]

　　对于边<u,v>从u向v连边，容量为1

　　若$(m*n-maxflow)/2>0$说明r可以扩大

 

这样就求出了最大的r

再用这个r建一遍图，跑最大流，在残量网络上DFS就可以找出所有可选的点。

就可以过POJ3155

把输出方案去掉就可以过Bzoj1312

 

但是博主傻傻不能理解为什么这样贪心一定能选出最多的人

 

/*by SilverN*/
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<queue>
#define LL long long
using namespace std;
const int INF=0x3f3f3f3f;
const double eps=1e-5;
const int mxn=1005;
int read(){
    int x=0,f=1;char ch=getchar();
    while(ch<'0' || ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0' && ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
struct EG{
    int x,y;
}eg[mxn<<4];
int deg[mxn];
//
struct edge{
    int v,nxt;
    double f;
}e[mxn<<4];
int hd[mxn],mct=1;
inline void add_edge(int u,int v,double f){
    e[++mct].v=v;e[mct].nxt=hd[u];e[mct].f=f;hd[u]=mct;return;
}
void insert(int u,int v,double f){
    add_edge(u,v,f); add_edge(v,u,0);
    return;
}
//
int n,m,S,T,U;
int d[mxn];
bool BFS(){
    memset(d,0,sizeof d);
    queue<int>q;
    d[S]=1;
    q.push(S);
    while(!q.empty()){
        int u=q.front();q.pop();
        for(int i=hd[u];i;i=e[i].nxt){
            int v=e[i].v;
            if(!d[v] && e[i].f>0){
                d[v]=d[u]+1;
                q.push(v);
            }
        }
    }
    return d[T];
}
double DFS(int u,double lim){
    if(u==T)return lim;
    double f=0,tmp;
    for(int i=hd[u];i;i=e[i].nxt){
        int v=e[i].v;
        if(d[v]==d[u]+1 && e[i].f>eps && (tmp=DFS(v,min(lim,e[i].f)))){
            e[i].f-=tmp;
            e[i^1].f+=tmp;
            lim-=tmp;
            f+=tmp;
            if(fabs(lim)<eps)return f;
        }
    }
    d[u]=0;
    return f;
}
double Dinic(){
    double res=0;
    while(BFS())res+=DFS(S,INF);
    return res;
}
void Build(double r){
    memset(hd,0,sizeof hd);mct=1;
    S=0;T=n+1;int i;
    for(i=1;i<=n;i++){
        insert(S,i,U);
        insert(i,T,U+2*r-deg[i]);
    }
    for(i=1;i<=m;i++){
        add_edge(eg[i].x,eg[i].y,1);
        add_edge(eg[i].y,eg[i].x,1);
    }
    return;
}
bool use[mxn];int cnt=0;
void DFS(int u){
    use[u]=1;++cnt;
    for(int i=hd[u];i;i=e[i].nxt){
        if(!use[e[i].v] && e[i].f>eps){DFS(e[i].v);}
    }
    return;
}
void solve(){
    double l=0,r=m; U=m;
    double X=1.0/n/n;
    while(r-l>X){
        double mid=(l+r)/2;
        Build(mid);
//        printf("mid:%.3f\n",mid);
        if((m*n-Dinic())/2>=eps){
            l=mid;
        }else r=mid;
    }
    Build(l);Dinic();
    return;
}
void init(){
    memset(hd,0,sizeof hd);mct=1;
    memset(use,0,sizeof use);cnt=0;
    return;
}
int main(){
    while(scanf("%d%d",&n,&m)!=EOF){
        if(!m){printf("1\n1\n");continue;}
        init();
        for(int i=1;i<=m;i++){
            eg[i].x=read();eg[i].y=read();
            ++deg[eg[i].x];
            ++deg[eg[i].y];
        }
        solve();
        DFS(S);
        printf("%d\n",cnt-1);
        for(int i=1;i<=n;i++)if(use[i])printf("%d\n",i);
        break;
    }
    return 0;
}