最小割之最大密度子图

最新推荐文章于 2024-10-01 23:05:47 发布

去旅行的一蜗牛

最新推荐文章于 2024-10-01 23:05:47 发布

阅读量1k

点赞数 18

文章标签：深度优先算法 c++

本文链接：https://blog.csdn.net/Daniel_mu/article/details/135416222

版权

最小割之最大密度子图

$n$ 个点 $m$ 条边的无向图 $G=\left\{V,E\right\}$ ，求最大密度子图 $G'=\left\{V',E'\right\}$ ，即子图有 $\frac{|E'|}{|V'|}$ 。

分析

$\Huge{答案 Maximize \frac{|E'|}{|V'|} =\frac{\sum_{e\in E}x_e}{\sum_{v\in V}x_v}}$

其中 $x_e, x_v \in {0,1}$ ，如果是 $1$ 表示在子图中， $0$ 表示不在子图中

并且如果边 $(u, v)$ 在子图中，边 $(u, v)$ 的两个端点 $u, v$ 也必然在子图中。

设密度为 $g$
即为 $=\frac{\sum_{e\in E}x_e}{\sum_{v\in V}x_v}$
变形:
$\sum_{e\in E}x_e = {\sum_{v\in V}x_v} g \\ \Leftrightarrow \sum_{e\in E}x_e - {\sum_{v\in V}x_v} g = 0$

我们构造 $\sum_{e \in E'}x_e - \sum_{v \in V'}g \cdot x_v$

若最优密度为 $D$ , 我们可以得到：

$\begin{cases}h(g)<0 & g>D \\ h(g)=0 & g=D\\ h(g)>0 & g<D\end{cases}$

所以，问题就转化为了求一个 $g$ ，使得 $h (g) = 0$

很明显我们可以二分答案 $g$ , 可以发现对于每条边 $e(u,v)\in E$ ，要加入子图中的前提是 $(u, v)$ 都在图中，所以容易发现这可以用最大权闭合图来解决

每条边作为一个点，向这条边的两个端点连 $I NF$ 的边
源点向所有原图中的边连边，容量为 $1$
原图中的点向汇点连边，容量为 $g$

代码

#include <bits/stdc++.h>
using namespace std;
#define N 110
#define M 1500 
#define INF 1e10
const double eps = 1e-8;

struct edge{
    int u, v;
}edges[M];
int n, m, S, T;
int deg[N];

struct node{
    int to, nxt;
    double w;
}edge[M];
int head[N], tot;

void add(int u, int v, double c1, double c2){
    edge[tot].to=v, edge[tot].w=c1, edge[tot].nxt=head[u], head[u]=tot++; 
    edge[tot].to=u, edge[tot].w=c2, edge[tot].nxt=head[v], head[v]=tot++; 
}

void build(double g){
    memset(head, -1, sizeof head), tot=0;
    for(int i=1; i<=m; i++) add(edges[i].u, edges[i].v, 1, 1);
    for(int i=1; i<=n; i++) add(S, i, m, 0), add(i, T, m+2*g-deg[i], 0);
}

int dep[N], cur[N];
bool bfs(){
    memset(dep, -1, sizeof dep);
    queue<int> Q;
    Q.push(S);
	dep[S] = 0;
	cur[S] = head[S];

    while(Q.size()){
        int u = Q.front();
        Q.pop();
        for(int i = head[u]; ~i; i = edge[i].nxt){
            int v = edge[i].to;
            if(dep[v] == -1 && edge[i].w > eps){
                dep[v] = dep[u]+1;
                cur[v] = head[v];
                if(v == T) return true;
                Q.push(v); 
            }
        }
    }
    return false;
}

double find(int u, double limit){
    if(u == T){
    	return limit;
	}
    double flow = 0;
    for(int i = cur[u]; ~i && flow < limit; i = edge[i].nxt){
        int v = edge[i].to;
        cur[u] = i;
        if(dep[v] == dep[u] + 1 && edge[i].w > eps){
            double t = find(v, min(limit - flow, edge[i].w));
            if(t < eps) dep[v] = -1;
            edge[i].w -= t;
			edge[i ^ 1].w += t;
			flow += t;
        }
    }
    return flow;
}

double dinic(double g){
    build(g);
    double res = 0, flow;
    while(bfs()){
    	while(flow = find(S, INF)){
    		res += flow;
		}
	}
    return res;
} 

int res = 0;
bool vis[N];
void dfs(int u){
    vis[u] = true;
    if(u != S) res ++ ;
    for(int i = head[u]; ~i; i = edge[i].nxt){
        int v = edge[i].to;
        if(edge[i].w > 0 && !vis[v]) dfs(v);
    }
}

int main(){
    scanf("%lld %lld", &n, &m);

    S = 0;
	T = n + 1;
    for(int i = 1;i <= m;i ++ ){
        int u, v;
		scanf("%lld %lld", &u, &v);
        edges[i] = {u, v};
        deg[u] ++ ;
		deg[v] ++ ;
    }
    double l = 0, r = m;
    while(l + eps < r){
        double mid = (l + r) / 2;
        if(m * n - dinic(mid) > eps) l = mid;
        else r = mid;
    }

    dinic(l);
    dfs(S);

    if(!res){
        puts("1\n1");
        return 0;
    }

    cout<<res<<endl;
    for(int i = 1; i <= n; i++)
        if(vis[i]) printf("%d\n",i);
    return 0;
}