最大权闭合子图 - [求最大点权的闭合子图]（算法分析）

Wuliwuliii

于 2020-02-26 22:43:22 发布

阅读量3.3k

点赞数 7

分类专栏：图论网络流文章标签：最大权闭合子图

本文链接：https://blog.csdn.net/qq_41730082/article/details/104526447

版权

图论同时被 2 个专栏收录

302 篇文章 4 订阅

订阅专栏

网络流

109 篇文章 0 订阅

订阅专栏

引言·什么是最大权闭合子图

先讲闭合子图的概念，就是一幅图中每个点，以及每个点的出边的点都在这幅图中，也就是这幅图中的所有点的出边都是指向子图内部的。

最大权闭合子图：在所有的闭合子图中，它所包含的子图的点的点权之和是最大的。

上述的问题，都是基于将权值放在点上去考虑，现在，我们想要去求解最大权闭合子图，需要把点权考虑成边权（边的流量）来计算。

证明·推导·分析过程

首先有一个有向连通图，每个点带有一个权值，例如：

Tips：按权值的正负连接到s和t：从贪心的角度来看，最大闭合子图的起点必然是正权值点，但是不能保证起点是哪个正权值点，而最小割是求S到T的最小割，于是乎，如果说有的正权值是作为闭合子图的末尾，实际上并不会影响到答案，这些在下文有阐述到。

此时，构建一个超级源点s，一个超级汇点t，所有的点按权值的正负连接到s和t上，其余边的边权设置为INF，转换成一个边权值有向图，如下图：

（注：点权为0的点可以忽略，对结果没有影响）

这时，可以得到小结论：

①该带边权有向图的关于s-t最小割，是简单割；

　　简单割：割集中所有的边，都与s或t相连接。

这里可以简单的想想，除了链接S和链接T的边，其余的边都是INF边，我们是不可能割INF边的。

　　显然的，因为不与s,t相连的边，权值都是INF，最小割不可能割在INF的边上；

　　这早在文章http://www.cnblogs.com/dilthey/p/7401563.html中就有出现提到过，实际上，这个带边权有向图就是二分图；

②该图中的每一个简单割产生的两个子图，我们记含有点s的是图S，含有点t的是图T，则图S是闭合图；

　　闭合图：在一个图中，我们选取一些点构成集合，若集合中任意点连接的任意出弧，所指向的终点也在V中，则这个集合以及所有这些边构成闭合图。

简单推理：因为中间的边（原边）的流量都设置为了INF，所以肯定会走到底的。

　　证明：简单割内不包含边权为INF的边，即不含有连通两个图的边（除了连接在t点上的边之外）；

　　　　　即，图S中没有边与图T连通，那么，所有的边都只能连接在图S之内，即为闭合图。

　　样例：

③最小割产生的图S和图T，图S为最大权闭合子图；

　　最大权闭合子图：在整个图中，有多个子图是满足闭合图的条件的，其中点权值之和最大的，为最大权闭合子图；

　　因为割集中所有的边，不是连接在s上，就是连接在t上；

　　我们记割集中，所有连接在s上的边的权值和为x1，所有连接在t上的边的权值和为x2，而割集中所有边权值和为X=x1+x2；

X = X1 + X2:是因为我们的割边，要么是链接S处，要么是链接T处。

　　又，记图S中所有点的权值和为W，记其中正权值之和为w1，负权值之和为 - w2，故W = w1 - w2；

　　而 W + X = w1 - w2 + x1 + x2，由于x2 = w2

X2 = W2: X2是T处的割边，而W2是图S的负权值点权和，又有负权值点是直接与T相连的，所以X2 = W2。

　　　　（因为图S中所有负权值的点，必然连接到t点，而图S必然要与t分割开；故割集中，“连接在t点上的边权值和”就是“图S中所有负权值点的权值之和，取负”）

　　因而W + X = w1 + x1；

　　而显然的，w1 + x1是整个图中所有正权值之和，记为SUM；

　　故W = SUM - X，即 “图S中所有点的权值和” = “整个图中所有正权值之和” - “割集中所有边权值和”；

　　然后，因为SUM为定值，只要我们取最小割，则“图S中所有点的权值和”就是最大的，即此时图S为图S为最大权闭合子图；

求解方法

最后，我们就有了求解这类问题的完整思路：

　　①先记录整个图中，所有正点权值的和；

　　②建立对应流网络，求最大流，最大流在数值上等于最小割，故我们得到了流网络的s-t最小割；

　　③“所有正点权值的和”减去“s-t最小割”，即得最大权闭合子图的权值和。

参考资料一

参考资料二

例题讲解

最经典的例题就是太空飞行计划问题。

首先，这里强调的是从S出发。所以，其实暗示了我们只能采取一些合适的最大流求最小割的算法，例如说ISAP就是不可以的，它的本质是从T往S的割集，例如说这样的情况就会出现问题：

从ISAP的角度出发，会使得它的高度变化变成：

如果说，我们利用T->5->2->S，以及T->4->2->S将“S->2”这条边的流量给流完了，实际上确实不合理的这样就变成了把T这端的变成了我们想要的类型，和我们上面的推导的算法过程是不符合的。

所以，我们求解的方法仍然是Dinic()来跑最大流求最小割，最后所要的点还是在S端的链接的点。

ans:
1 2
1 2 3
1

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <bitset>
#include <unordered_map>
#include <unordered_set>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
bool The_end;
inline int read()
{
    int x = 0; The_end = false;
    char c = getchar();
    while(c < '0' || c > '9') c = getchar();
    while(c >= '0' && c <= '9')
    {
        x = x * 10 + c - '0';
        c = getchar();
    }
    if(c == '\n' || c == '\r') The_end = true;
    return x;
}
const int maxN = 2e2 + 7, maxM = 6e3 + 7;
int M, N, head[maxN], cnt;
int get_money[55], need_cost[55];
struct Eddge
{
    int nex, to; ll flow;
    Eddge(int a=-1, int b=0, ll c=0):nex(a), to(b), flow(c) {}
}edge[maxM];
inline void addEddge(int u, int v, ll w)
{
    edge[cnt] = Eddge(head[u], v, w);
    head[u] = cnt++;
}
inline void _add(int u, int v, ll w) { addEddge(u, v, w); addEddge(v, u, 0); }

struct Max_Flow
{
    int deep[maxN], cur[maxN], S, T, node;
    queue<int> Q;
    inline bool bfs()
    {
        while(!Q.empty()) Q.pop();
        for(int i=0; i<=node; i++) deep[i] = 0;
        deep[S] = 1;
        Q.push(S);
        int u;
        while(!Q.empty())
        {
            u = Q.front(); Q.pop();
            for(int i=head[u], v, f; ~i; i=edge[i].nex)
            {
                v = edge[i].to; f = edge[i].flow;
                if(f && !deep[v])
                {
                    deep[v] = deep[u] + 1;
                    Q.push(v);
                }
            }
        }
        return deep[T];
    }
    int dfs(int u, int dist)
    {
        if(u == T) return dist;
        for(int &i=cur[u], v, f, di; ~i; i=edge[i].nex)
        {
            v = edge[i].to; f = edge[i].flow;
            if(f && deep[v] == deep[u] + 1)
            {
                di = dfs(v, min(dist, f));
                if(di)
                {
                    edge[i].flow -= di; edge[i ^ 1].flow += di;
                    return di;
                }
            }
        }
        return 0;
    }
    inline int Dinic()
    {
        int ans = 0, tmp;
        while(bfs())
        {
            for(int i=0; i<=node; i++) cur[i] = head[i];
            while((tmp = dfs(S, INF))) ans += tmp;
        }
        return ans;
    }
} mf;
inline void init()
{
    cnt = 0; mf.S = 0; mf.T = N + M + 1; mf.node = N + M + 2;
    for(int i=0; i<=mf.node; i++) head[i] = -1;
}
vector<int> vt[55];
bool used[maxN] = {false};
int main()
{
    scanf("%d%d", &M, &N);
    init();
    ll sum = 0;
    for(int i=1, x = 0; i<=M; i++)
    {
        x = 0;
        The_end = false;
        while(!The_end)
        {
            if(!x)
            {
                x = read(); get_money[i] = x; sum += x;
                _add(mf.S, i, x);
            }
            else
            {
                x = read(); vt[i].push_back(x);
                _add(i, x + M, INF);
            }
        }
    }
    for(int i=1; i<=N; i++)
    {
        scanf("%d", &need_cost[i]);
        _add(M + i, mf.T, need_cost[i]);
    }
    ll tmp = mf.Dinic();
    for(int i=head[mf.S], v; ~i; i=edge[i].nex)
    {
        v = edge[i].to;
        if(mf.deep[v])
        {
            printf("%d ", v);
            for(auto x : vt[v]) used[x] = true;
        }
    }
    if(tmp < sum) printf("\n");
    for(int i=1; i<=N; i++) if(used[i]) printf("%d ", i);
    if(tmp < sum) printf("\n");
    printf("%lld\n", sum - tmp);
    return 0;
}