生活的艰辛（最大密度子图）：无点权情况

生活的艰辛

约翰是一家公司的 CEO。

公司的股东决定让他的儿子斯科特成为公司的经理。

约翰十分担心，儿子会因为在经理岗位上表现优异而威胁到他 CEO 的位置。

因此，他决定精心挑选儿子要管理的团队人员，让儿子知道社会的险恶。

已知公司中一共有 $n$ 名员工，员工之间共有 $m$ 对两两矛盾关系。

如果将一对有矛盾的员工安排在同一个团队，那么团队的管理难度就会增大。

一个团队的管理难度系数等于团队中的矛盾关系对数除以团队总人数。

团队的管理难度系数越大，团队就越难管理。

约翰希望给儿子安排的团队的管理难度系数尽可能大。

请帮帮他。

以上图为例，管理难度系数最大的团队由 $1,2,4,5$ 号员工组成，他们 $4$ 人中共有 $5$ 对矛盾关系，所以管理难度系数为 $\frac{5}{4}$。

如果我们将 $3$ 号员工也加入到团队之中，那么管理难度系数就会降至 $\frac{6}{5}$。

输入格式

第一行包含两个整数 $n$ 和 $m$。

接下来 $m$ 行，每行包含两个整数 $a_i$ 和 $b_i$，表示员工 $a_i$ 和 $b_i$ 之间存在矛盾。

所有员工编号从 $1$ 到 $n$。

每个矛盾对最多在输入中出现一次，且介绍矛盾对时，员工介绍顺序是随意的。

输出格式

首先输出一个整数 $k$，表示安排给斯科特的团队人员数量。

接下来 $k$ 行，以升序输出团队每个成员的编号，每行一个。

如果答案不唯一，则输出任意一种即可。

注意：至少要选择一名员工。

数据范围

$1 \le n \le 100$, $0 \le m \le 1000$, $1 \le k \le n$

输入样例1：

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

输出样例1：

4
1
2
4
5

输入样例2：

4 0

输出样例2：

1
1

提示

注意样例 $2$ 中，任意团队的管理困难系数都是 $0$，这种情况输出任意非空方案即可。

思路

• 首先这道题就是很典型的无点权情况的最大密度子图。

• 且这道题要输出方案，那么我们因为 V ′ = S − { s } V'=S-\{s\} V′=S−{s}，其中 $V^{\prime }$ 是点集。题目要求的。

• 最大密度子图的点数是 $2|V|+|E|$。

• 拓展：求割的方案数就是沿着残留网络流量大于 $0$ 的边走，如果能走到的就是 $S$ 集合，如果不能走到的就是 $T$ 集合。

• 细节1：本道题是由小数的，因此 dinic 算法得细心点。
• 细节2：本题设置 U 为 m，保证 2 * g - deg[i] + U > 0。
• 细节3：每次二分的值重新建图。
• 细节4：注意无向边（原图内是无向边，但我们新增的虚拟源点和汇点不是无向边）。

代码

//那么这道题就是很典型的无边权、无点权的最大密度子图的题

#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>

using namespace std;

const int N = 110,M = (N*2+1000)*2+10,INT = 1e8;

int e[M],ne[M],h[N],idx;
double f[M];
int n,m,S,T;
bool st[N];
int cur[N],d[N];
struct E{
    int x,y;
}ed[M];
int ans;
int din[N];

void add(int a,int b,double c1,double c2){//为了创造无向边
    e[idx]=b,f[idx]=c1,ne[idx]=h[a],h[a]=idx++;
    e[idx]=a,f[idx]=c2,ne[idx]=h[b],h[b]=idx++;
}

void build(double g){
    memset(h,-1,sizeof h);
    
    idx=0;
    
    for(int i=1;i<=m;i++)add(ed[i].x,ed[i].y,1,1);//无向边（四条边合并成两条边）
    
    for(int i=1;i<=n;i++){
        add(S,i,m,0);
        add(i,T,m+2*g-din[i],0);
    }
}

bool bfs(){
    queue<int>q;
    
    q.push(S);
    
    memset(d,-1,sizeof d);
    
    d[S]=0,cur[S]=h[S];
    
    while(q.size()){
        int t=q.front();
        q.pop();
        
        for(int i=h[t];~i;i=ne[i]){
            int ver=e[i];
            
            if(d[ver]==-1&&f[i]>0){
                d[ver]=d[t]+1;
                cur[ver]=h[ver];
                if(ver==T)return true;
                q.push(ver);
            }
        }
    }
    return false;
}

double find(int u,double lim){
    if(u==T)return lim;
    
    double flow=0;
    
    for(int i=cur[u];~i&&flow<lim;i=ne[i]){
        int ver=e[i];
        
        cur[u]=i;
        
        if(d[ver]==d[u]+1&&f[i]>0){
            double t=find(ver,min(f[i],lim-flow));
            if(t<=0)d[ver]=-1;
            f[i]-=t,f[i^1]+=t,flow+=t;
        }
    }
    return flow;
}

double dinic(double x){
    build(x);
    
    double r=0,flow;
    
    while(bfs())while(flow=find(S,INT))r+=flow;
    
    return r;
}

void dfs(int u){
    st[u]=true;
    if(u!=S)ans++;//选中的人数 + 1
    for(int i=h[u];~i;i=ne[i]){
        int ver=e[i];
        if(f[i]>0&&!st[ver]) dfs(ver);
    }
}

int main(){
    cin>>n>>m;
    
    S=0,T=n+1;
    
    for(int i=1;i<=m;i++){
        int a,b;
        cin>>a>>b;
        din[a]++,din[b]++;
        ed[i]={a,b};
    }
    
    double l=0,r=m;//其中m为偏移量，也就是U
    //本题设置 U 为 m，保证 2 * g - deg[i] + U > 0
    while(r-l>1e-8){
        double mid=(l+r)/2;
        double t=dinic(mid);
        if(n*m-t>0)l=mid;
        else r=mid;
    }
    
    dinic(l);//用最终答案计算一遍最小割（只能取 l，取 r 可能不合法）
    dfs(S); //找出合法方案
    
    if(ans==0){
        cout<<"1"<<endl<<"1";
    }else{
        
        cout<<ans<<endl;
        
        for(int i=1;i<=n;i++){
            if(st[i]){
                cout<<i<<endl;
            }
        }
    }
    return 0;
}