最大子独立集（简单的树形dp）

 

最大子独立集

对于一棵有N个结点的无根树，选出尽量多的结点，使得任何两个结点均不相邻（称为最大独立集）。

• 1
• 2

输入

 第1行：1个整数N(1 <= N <= 6000)，表示树的结点个数，树中结点的编号从1..N
接下来N-1行，每行2个整数u，v，表示树中的一条边连接结点u和v

• 1
• 2
• 3

输出

 第1行：1个整数，表示最大独立集的结点个数

• 1
• 2

样例输入

11
1 2
1 3
3 4
3 5
3 6
4 7
4 8
5 9
5 10
6 11

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12

样例输出

7

代码（不太好的代码，有多个判断，需要进行两次函数遍历）

#include<stdio.h>
#include<vector>
#include<string.h>
#include<algorithm>
#include<cmath>
using namespace std;
#define MAXN 10005

vector<int>a[MAXN];
bool vis[MAXN];
int dp[MAXN][2];

int Dp(int x,int flag)
{
    if(dp[x][flag] >= 0)
        return dp[x][flag];
    int c = 0;
    for(int i = 0; i < a[x].size(); i++){
        if(!vis[a[x][i]])
            c++;
    }
    //printf("%d\n",c);
    if(c == 0){
        if(flag == 1){
            dp[x][1] = 1;
            return 1;
        }
        else{
            dp[x][0] = 0; return 0;
        }
    }
    int sum=0;
    if(flag)
        sum++;

    for(int i = 0; i < a[x].size(); i++)
    {
        if(!vis[a[x][i]] && flag)
        {
            vis[x] = true;
            sum += Dp(a[x][i],!flag);

        }
        if(!vis[a[x][i]] && !flag)
        {
            vis[x] = true;
            sum += max(Dp(a[x][i],flag),Dp(a[x][i],!flag));

        }
    }
    dp[x][flag] = sum;
    return dp[x][flag];
}

int main()
{
    int n;
    memset(vis,false,sizeof(vis));
    memset(dp,-1,sizeof(dp));
    scanf("%d",&n);
    for(int i = 0; i < n-1; i++){
        int c,d;
        scanf("%d%d",&c,&d);
        a[c].push_back(d);
        a[d].push_back(c);
    }
    int w = Dp(1,1);
    memset(vis,false,sizeof(vis));

  w = max(w,Dp(1,0));
    printf("%d\n",w);
    return 0;
}

第二种，只要进行一次遍历就可以求了，而且不要多余的判断，时间复杂度更低一点：

#include<cstdio>
#include<vector>
#include<iostream>
using namespace std;
int n;
int Dp[6005][2];//状态
vector<int>G[6005];//儿子
void Tdp(int x,int fa){
    Dp[x][1]=1;//因为每个点都算一个，即使是叶节点
    for(int i=0;i<G[x].size();i++){//枚举儿子
        int v=G[x][i];//简化程序
        if(v==fa)continue;//儿子等于父亲
        Tdp(v,x);//递归求解，先计算下层的节点（想想为什么）
        Dp[x][1]+=Dp[v][0];
        Dp[x][0]+=max(Dp[v][0],Dp[v][1]);//转移
    }
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<n;i++){
        int x,y;
        scanf("%d%d",&x,&y);
        G[x].push_back(y);
        G[y].push_back(x);//存入数组
    }
    Tdp(1,0);//把1号当成根，由于题目中没有0号节点，所以父亲为0（最好为-1）
    printf("%d\n",max(Dp[1][0],Dp[1][1]));//最优解
}