树的最小支配集、最小点覆盖、最大独立集【模板】

最新推荐文章于 2021-08-02 22:00:35 发布
原创 最新推荐文章于 2021-08-02 22:00:35 发布 · 434 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍如何使用贪心算法求解图论中的最小支配集、最小点覆盖及最大独立集问题，通过深度优先搜索和反向序列检查，实现高效求解。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

最小支配集：指从所有顶点中取尽量少的点组成一个集合，使得剩下的所有点都与取出来的点有边相连。顶点个数最小的支配集被称为最小支配集。这里用贪心法来求。

1.以1号点深度优先搜索整棵树，求出每个点在DFS中的编号和每个点的父亲节点编号。 
2.按DFS的反向序列检查，如果当前点既不属于支配集也不与支配集中的点相连，且它的父亲也不属于支配集，将其父亲点加入支配集，支配集个数加1。 
3.标记当前结点、当前结点的父节点(属于支配集)、当前结点的父节点的父节点(与支配集中的点相连)。

部分模板

int Greedy()//贪心求最小支配集
{
   memset(S,0,sizeof(S));
   memset(Set,0,sizeof(Set));
   int ans=0;
    for(int i=now-1;i>=0;i--)//反向序列检查
    {
        int t=Newpos[i];
        if(!S[t])//当前点未被覆盖，也就是当前点既不属于支配集，也不与支配集中的点相连

        {
            if(!Set[Father[t]])//当前点的父亲结点不属于支配集，
            {
                Set[Father[t]]=1;//将父节点加入支配集
                ans++; //顶点个数加1
            }

            S[t]=1;
            S[Father[t]]=1;
            S[Father[Father[t]]]=1;//标记当前点、当前结点的父节点、当前结点的父节点的父节点
        }
    }
    return ans;
}

完整模板

#include<bits/stdc++.h>
#define pi acos(-1.0)
#define inf 0x3f3f3f3f
#define linf 0x3f3f3f3f3f3f3f3fLL
#define ms(a,b) memset(a,b,sizeof(a))
using namespace std;
typedef long long ll;
int min3(int a,int b,int c){return min(min(a,b),c);}
int max3(int a,int b,int c){return max(max(a,b),c);}
int gcd(int x, int y){if(y==0)return x;return gcd(y, x%y);}
inline 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;}
const int maxn=1e5+5;

struct edgenode
{
    int to;
    int next;
}edge[2*maxn];
int cnt;
int Head[maxn];
int Newpos[maxn];
int Father[maxn];
bool vis[maxn];
int n,now;
//NewPos[]表示深度优先遍历序列的第i个点是哪个点
//now表示当前深度优先遍历序列中已经有多少个点了
//vis[]用来深度优先遍历的判重
//father[]表示点i的父亲节点编号
void add(int u,int v)
{
     edge[cnt].to=v;
     edge[cnt].next=Head[u];
     Head[u]=cnt++;

}
void dfs(int x)//得到深度优先队列的反向序列
{
    Newpos[now++]=x;
    for(int i=Head[x];~i;i=edge[i].next)
    {
        if(!vis[edge[i].to])
        {
            vis[edge[i].to]=1;
            Father[edge[i].to]=x;
            dfs(edge[i].to);
        }
    }
}
bool S[maxn];
bool Set[maxn];
//S[i]为1，表示第i个点被覆盖了
//Set[i]表示点i属于要求的点集

int Greedy()//贪心求最小支配集
{
   memset(S,0,sizeof(S));
   memset(Set,0,sizeof(Set));
   int ans=0;
    for(int i=now-1;i>=0;i--)//反向序列检查
    {
        int t=Newpos[i];
        if(!S[t])//当前点未被覆盖，也就是当前点既不属于支配集，也不与支配集中的点相连

        {
            if(!Set[Father[t]])//当前点的父亲结点不属于支配集，
            {
                Set[Father[t]]=1;//将父节点加入支配集
                ans++; //顶点个数加1
            }

            S[t]=1;
            S[Father[t]]=1;
            S[Father[Father[t]]]=1;//标记当前点、当前结点的父节点、当前结点的父节点的父节点
        }
    }
    return ans;
}
void init()
{
    memset(Head,-1,sizeof(Head));
    memset(vis,0,sizeof(vis));
    memset(Father,0,sizeof(Father));
    memset(Newpos,0,sizeof(Newpos));
    cnt=0;
}
int main()
{
    int u,v;
    scanf("%d",&n);
    init();
    for(int i=0;i<n-1;i++)
    {
        scanf("%d%d",&u,&v);
        add(u,v);
        add(v,u);
    }
    vis[1]=1;
    Father[1]=1;
    dfs(1);

    printf("%d\n",Greedy());

    return 0;
}

最小点覆盖：指从所有顶点中取尽量少的点组成一个集合，使得集合中所有的点都与取出来的点有边相连。顶点个数最小的覆盖集被称为最小点覆盖。
贪心策略：如果当前点和当前点的父节点都不属于顶点覆盖集合，则将父节点加入到顶点覆盖集合中，并标记当前节点和其父节点都被覆盖。

部分模板

int Greedy()//贪心求最小点覆盖
{
    memset(S,0,sizeof(S));
    memset(Set,0,sizeof(Set));
    int ans = 0;
    for(int i = now-1; i >= 0; i--)//反向序列检查
    {
        int t = Newpos[i];
        if(!S[t] && !S[Father[t]])//当前点和当前点的父节点都不属于顶点覆盖集合
        {
            Set[Father[t]] = 1;  //当前点的父节点加入到顶点覆盖集合中
            ans++;                  //顶点个数+1
            S[t] = 1;
            S[Father[t]] = 1;
            //标记当前点、当前结点的父节点
        }
    }
    return ans;
}

完整模板

#include<bits/stdc++.h>
#define pi acos(-1.0)
#define inf 0x3f3f3f3f
#define linf 0x3f3f3f3f3f3f3f3fLL
#define ms(a,b) memset(a,b,sizeof(a))
using namespace std;
typedef long long ll;
int min3(int a,int b,int c){return min(min(a,b),c);}
int max3(int a,int b,int c){return max(max(a,b),c);}
int gcd(int x, int y){if(y==0)return x;return gcd(y, x%y);}
inline 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;}
const int maxn=1e5+5;

struct edgenode
{
    int to;
    int next;
}edge[2*maxn];
int cnt;
int Head[maxn];
int Newpos[maxn];
int Father[maxn];
bool vis[maxn];
int n,now;
//NewPos[]表示深度优先遍历序列的第i个点是哪个点
//now表示当前深度优先遍历序列中已经有多少个点了
//vis[]用来深度优先遍历的判重
//father[]表示点i的父亲节点编号
void add(int u,int v)
{
     edge[cnt].to=v;
     edge[cnt].next=Head[u];
     Head[u]=cnt++;

}
void dfs(int x)//得到深度优先队列的反向序列
{
    Newpos[now++]=x;
    for(int i=Head[x];~i;i=edge[i].next)
    {
        if(!vis[edge[i].to])
        {
            vis[edge[i].to]=1;
            Father[edge[i].to]=x;
            dfs(edge[i].to);
        }
    }
}
bool S[maxn];
bool Set[maxn];
//S[i]为1，表示第i个点被覆盖了
//Set[i]表示点i属于要求的点集

int Greedy()//贪心求最小点覆盖
{
    memset(S,0,sizeof(S));
    memset(Set,0,sizeof(Set));
    int ans = 0;
    for(int i = now-1; i >= 0; i--)//反向序列检查
    {
        int t = Newpos[i];
        if(!S[t] && !S[Father[t]])//当前点和当前点的父节点都不属于顶点覆盖集合
        {
            Set[Father[t]] = 1;  //当前点的父节点加入到顶点覆盖集合中
            ans++;                  //顶点个数+1
            S[t] = 1;
            S[Father[t]] = 1;
            //标记当前点、当前结点的父节点
        }
    }
    return ans;
}
void init()
{
    memset(Head,-1,sizeof(Head));
    memset(vis,0,sizeof(vis));
    memset(Father,0,sizeof(Father));
    memset(Newpos,0,sizeof(Newpos));
    cnt=0;
}
int main()
{
    int u,v;
    scanf("%d",&n);
    init();
    for(int i=0;i<n-1;i++)
    {
        scanf("%d%d",&u,&v);
        add(u,v);
        add(v,u);
    }
    vis[1]=1;
    Father[1]=1;
    dfs(1);

    printf("%d\n",Greedy());

    return 0;
}

最大独立集：指从所有顶点中取尽量多的点组成一个集合，使得这些点之间没有边相连。顶点个数最多的独立集被称为最大独立集。
贪心策略：如果当前节点没有被覆盖，则将当前节点加入独立集，并标记当前节点和其父节点都被覆盖。

部分模板

int Greedy()//贪心求最小点覆盖
{
    memset(S,0,sizeof(S));
    memset(Set,0,sizeof(Set));
    int ans = 0;
    for(int i = now-1; i >= 0; i--)//反向序列检查
    {
        int t = Newpos[i];
        if(!S[t])//当前点未被覆盖
        {
            Set[t] = 1;  //将当前点加入独立集
            ans++;       //独立集点个数加1
            S[t] = 1;
            S[Father[t]] = 1;
            //标记当前点、当前结点的父节点
        }
    }
    return ans;
}

完整模板

#include<bits/stdc++.h>
#define pi acos(-1.0)
#define inf 0x3f3f3f3f
#define linf 0x3f3f3f3f3f3f3f3fLL
#define ms(a,b) memset(a,b,sizeof(a))
using namespace std;
typedef long long ll;
int min3(int a,int b,int c){return min(min(a,b),c);}
int max3(int a,int b,int c){return max(max(a,b),c);}
int gcd(int x, int y){if(y==0)return x;return gcd(y, x%y);}
inline 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;}
const int maxn=1e5+5;

struct edgenode
{
    int to;
    int next;
}edge[2*maxn];
int cnt;
int Head[maxn];
int Newpos[maxn];
int Father[maxn];
bool vis[maxn];
int n,now;
//NewPos[]表示深度优先遍历序列的第i个点是哪个点
//now表示当前深度优先遍历序列中已经有多少个点了
//vis[]用来深度优先遍历的判重
//father[]表示点i的父亲节点编号
void add(int u,int v)
{
     edge[cnt].to=v;
     edge[cnt].next=Head[u];
     Head[u]=cnt++;

}
void dfs(int x)//得到深度优先队列的反向序列
{
    Newpos[now++]=x;
    for(int i=Head[x];~i;i=edge[i].next)
    {
        if(!vis[edge[i].to])
        {
            vis[edge[i].to]=1;
            Father[edge[i].to]=x;
            dfs(edge[i].to);
        }
    }
}
bool S[maxn];
bool Set[maxn];
//S[i]为1，表示第i个点被覆盖了
//Set[i]表示点i属于要求的点集

int Greedy()//贪心求最小点覆盖
{
    memset(S,0,sizeof(S));
    memset(Set,0,sizeof(Set));
    int ans = 0;
    for(int i = now-1; i >= 0; i--)//反向序列检查
    {
        int t = Newpos[i];
        if(!S[t])//当前点未被覆盖
        {
            Set[t] = 1;  //将当前点加入独立集
            ans++;       //独立集点个数加1
            S[t] = 1;
            S[Father[t]] = 1;
            //标记当前点、当前结点的父节点
        }
    }
    return ans;
}
void init()
{
    memset(Head,-1,sizeof(Head));
    memset(vis,0,sizeof(vis));
    memset(Father,0,sizeof(Father));
    memset(Newpos,0,sizeof(Newpos));
    cnt=0;
}
int main()
{
    int u,v;
    scanf("%d",&n);
    init();
    for(int i=0;i<n-1;i++)
    {
        scanf("%d%d",&u,&v);
        add(u,v);
        add(v,u);
    }
    vis[1]=1;
    Father[1]=1;
    dfs(1);

    printf("%d\n",Greedy());

    return 0;
}

 

解题报告：X、骑士共存问题（最大独立集）（匈牙利 / 最大流）
繁凡さん的博客
08-02 385
X、骑士共存问题（最大独立集）（匈牙利 / 最大流） 题目链接 【问题分析】 二分图最大独立集，转化为二分图最大匹配，从而用最大流解决。 【建模方法】 首先把棋盘黑白染色，使相邻格子颜色不同。把所有可用的黑色格子看做二分图X集合中顶点，可用的白色格子看做Y集合顶点。建立附加源S汇T，从S向X集合中每个顶点连接一条容量为1的有向边，从Y集合中每个顶点向T连接一条容量为1的有向边。从每个可用的黑色格子向骑士一步能攻击到的可用的白色格子连接一条容量为无穷大的有向边。求出网络最大流，要求的结果就是可用格子的数量减
二分图匹配 + 最小点覆盖 + 最小支配集 + 最大独立集（模板）
jiangkun0331的博客
08-19 636
选课（二分匹配） Poj1649 COURSES 一共有N个学生跟P门课程一个学生可以任意选一 门或多门课，你需写一个程序，判断给定的输入是否可以满足以下条件。 1.每个学生选的都是不同的课(即不能有两个学生选同一门课) 2.即P门课都被成功选过 注意：是课程匹配的学生，学生没课上没事。 输入 第一行一个T代表T(T ≤ 10)组数据 对于每组测试样例，先输入两个整数P， N(P课程数 N学生数)...
hdu 1068 Girls and Boys（最大独立集模板）
TUT我好菜啊
07-27 514
Girls and Boys Time Limit: 20000/10000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 10501    Accepted Submission(s): 4850 Problem Description the seco
POJ 1419 最大独立集 模板
ureaster的博客
09-29 462
#include #include #include #include using namespace std; int T,n,m,a,b,g[110][110],vis[110]; vectorans; vectorcnt; void dfs(int now) { if(now==n+1) { if(ans.size()<cnt.size()) ans=cnt; return; }
树的最小支配集&&最小点覆盖&&最大独立集模板
代码改变世界，keep coding。
10-18 1588
/* 覆盖i，要么是父节点覆盖，要么是自己，要么是孩子，所以三种状态（和上面的对应）： 1、点i自己覆盖自己，i的所有孩子都覆盖，用dp[i][0]表示； 2、点i被自己的孩子覆盖，i和i的所有孩子都覆盖，用dp[i][1]表示； 3、点i被父节点覆盖，i的所有孩子都覆盖，用dp[i
ACM模板(几乎全)
10-15
- \( I \) 是极大(最大)独立集，当且仅当图 \( G \) 中除 \( I \) 集以外的所有顶点组成一个极小(最小)覆盖集，即满足以下等式：\(\alpha(G)\)（覆盖数）+ \(\beta(G)\)（独立数）= \(G\) 的顶点数。 - **支配集与...
福州大学ACM模板
04-28
- **独立集与支配集**：在图中寻找最大独立集或最小支配集。 ### 六、数论 #### 数论概览 数论是ACM竞赛中的另一个重要领域： - **欧几里德算法**：求最大公约数的方法。 - **模线性方程**：求解形如\(ax \equiv...
全面的ACM算法模板：图论、数论到数据结构
- 独立集、覆盖集、支配集：独立集是图中互不相邻的顶点集合；覆盖集是图中至少包含每个顶点的边的集合；支配集是能覆盖所有顶点的最小顶点集合。 - DFS（深度优先搜索）：遍历图的一种方法，用于发现边连接的顶点...
ACM算法模板和pku代码
11-09
二分图最大独立集 通讯站天线覆盖 二分图拆分后匹配 二分图某边唯一匹配 最小权匹配 海上矿工 floyd预处理 最大权匹配,需要非完全图转完全图 传递闭包+最小路径覆盖 可以重复经过点 图论 网络流 Adding-the-...
二分图求最大独立集模板
weixin_30266885的博客
08-02 141
#pragma GCC optimize(2) #pragma GCC optimize(3) #pragma GCC optimize(4) #include<bits/stdc++.h> #define LL long long #define LD long double #define ull unsigned long long #define f...
最小点覆盖 模版
ShineRoyal
08-13 468
dfs函数是寻找该点能否找到另一个与之相连的点连接。#include<stdio.h> #include<iostream> #include<string.h> #include<vector> using namespace std; #define N 505 int n,m; vector<int>v[N]; //表示左边各点连接了的右边的点，其实存的是边的关系 bool flag[N
最大团与最大独立模板+模板题
he_qingjun的博客
08-02 240
这里有几个概念要清楚： 最大团： V中取K个顶点，两点间相互连接 最大独立集： V中取K个顶点，两点间不连接 最大团数量 = 补图中最大独立集数，最大独立集数=补图中最大团数量 第一个回溯板子，，一般没啥用 #include <iostream> #include <cstring> using namespace std; const int N = 1000; bool g[N][N]; bool x[N]; int cnt, bestn; int n, e; void b
POJ 3041 Asteroids ———— 匈牙利算法模板题 （最小点覆盖）
连长少尉
11-19 488
Bessie wants to navigate her spaceship through a dangerous asteroid field in the shape of an N x N grid (1 <= N <= 500). The grid contains K asteroids (1 <= K <= 10,000), which are conveni...
树形DP求树的最小支配集,最小点覆盖,最大独立集
Falcon的博客
11-19 479
转自：https://www.cnblogs.com/Ash-ly/p/5783877.html 一:最小支配集 考虑最小支配集,每个点有两种状态,即属于支配集合或者不属于支配集合,其中不属于支配集合时此点还需要被覆盖,被覆盖也有两种状态,即被子节点覆盖或者被父节点覆盖.总结起来就是三种状态,现对这三种状态定义如下: 1):dp[i][0],表示点 i 属于支配集合,并且以点 i 为根的子树都被覆盖了的情况下支配集中所包含最少点的个数. 2):dp[i][1],表示点 i 不属于支配集合,且以 i
二分图最小点覆盖模版（LRJ）
勿忘初衷
03-19 1350
#include #include #include #include using namespace std; const int maxn = 1000 + 5; // 单侧顶点的最大数目 // 二分图最大基数匹配 struct BPM { int n, m; // 左右顶点个数 vector G[maxn]; //
最大独立集个数模板 + 最大团计数模板
_llc的博客
10-04 774
并没有看懂求最大团个数的算法原理???,已知看到最好的解释最大团blog POJ 2989 最大团计数模板 R集合是 最大团已经加入的点 P集合是 可能加入的点,且与R集合所有的点存在边(???) 还是不太明白X集合的作用 #include <iostream> #include <cstring> using namespace std; const int m...
poj 3041Asteroids 二分匹配求最小点覆盖模板题
ijbuhv的专栏
03-21 717
//最大匹配=最小覆盖 //这题是求最小覆盖点的模板题 #include #include #include using namespace std; const int maxn = 510; int line[maxn][maxn]; int match[maxn]; int vis[maxn]; int N , K; int find(int start) {  
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值