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

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

摘要生成于 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;
}

 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值