最小支配集：指從所有頂點中取儘量少的點組成一個集合，使得剩下的所有點都與取出來的點有邊相連。頂點個數最小的支配集被稱為最小支配集。這裡用貪心法來求。

1.以1號點深度優先搜尋整棵樹，求出每個點在DFS中的編號和每個點的父親節點編號。
2.按DFS的反向序列檢查，如果當前點既不屬於支配集也不與支配集中的點相連，且它的父親也不屬於支配集，將其父親點加入支配集，支配集個數加1。
3.標記當前結點、當前結點的父節點(屬於支配集)、當前結點的父節點的父節點(與支配集中的點相連)。

#include<iostream>
#include<algorithm>
#include<cstdio>
 

#include<cstring>
using namespace std;
const int MAXN = 20020;

struct EdgeNode
{
    int to;
    int next;
}Edges[MAXN];
int Head[MAXN],father[MAXN],NewPos[MAXN];
bool vis[MAXN];
//NewPos[]表示深度優先遍歷序列的第i個點是哪個點
//now表示當前深度優先遍歷序列中已經有多少個點了
//vis[]用來深度優先遍歷的判重
//father[]表示點i的父親節點編號
int N,M,now;
void DFS(int x)   //得到深度優先佇列的反向序列
 

{
    NewPos[now++] = x;
    for(int k = Head[x]; k != -1; k = Edges[k].next)
    {
        if(!vis[Edges[k].to])
        {
            vis[Edges[k].to] = true;
            father[Edges[k].to] = x;
            DFS(Edges[k].to);
        }
    }
}

//S[i]為true，表示第i個點被覆蓋了
//Set[i]表示點i屬於要求的點集
bool S[MAXN],Set[MAXN];
int
 
 Greedy()//貪心求最小支配集
{
    memset(S,0,sizeof(S));
    memset(Set,0,sizeof(Set));
    int ans = 0;
    for(int i = N-1; i >= 1; i--)//反向序列檢查
    {
        int t = NewPos[i];
        if(!S[t])//當前點未被覆蓋，也就是當前點既不屬於支配集，也不與支配集中的點相連
        {
            if(!Set[father[t]])//當前點的父親結點不屬於支配集，
            {
                Set[father[t]] = true;  //將父節點加入支配集
                ans++;                  //頂點個數加1
            }
            S[t] = true;
            S[father[t]] = true;
            S[father[father[t]]] = true;
            //標記當前點、當前結點的父節點、當前結點的父節點的父節點
        }
    }
    return ans;
}

int main()
{
    int u,v;
    while(~scanf("%d",&N))
    {   //初始化
        memset(Edges,0,sizeof(Edges));
        memset(Head,-1,sizeof(Head));
        memset(father,0,sizeof(father));
        memset(vis,false,sizeof(vis));
        memset(NewPos,0,sizeof(NewPos));
        int id = 0;
        for(int i = 0; i < N-1; ++i)
        {
            scanf("%d%d",&u,&v);
            Edges[id].to = v;
            Edges[id].next = Head[u];
            Head[u] = id++;
            Edges[id].to = u;
            Edges[id].next = Head[v];
            Head[v] = id++;
        }
        now = 0;
        vis[1] = true;
        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 = N-1; i >= 1; i--)//反向序列檢查
    {
        int t = NewPos[i];
        if(!S[t] && !S[father[t]])//當前點和當前點的父節點都不屬於頂點覆蓋集合
        {
            Set[father[t]] = true;  //當前點的父節點加入到頂點覆蓋集合中
            ans++;                  //頂點個數+1
            S[t] = true;
            S[father[t]] = true;
            //標記當前點、當前結點的父節點
        }
    }
    return ans;
}

最大獨立集：指從所有頂點中取儘量多的點組成一個集合，使得這些點之間沒有邊相連。頂點個數最多的獨立集被稱為最大獨立集。
貪心策略：如果當前節點沒有被覆蓋，則將當前節點加入獨立集，並標記當前節點和其父節點都被覆蓋。

int Greedy()//貪心求最大獨立集
{
    memset(S,0,sizeof(S));
    memset(Set,0,sizeof(Set));
    int ans = 0;
    for(int i = N-1; i >= 1; i--)//反向序列檢查
    {
        int t = NewPos[i];
        if(!S[t])//當前點未被覆蓋
        {

            Set[t] = true;  //將當前點加入獨立集
            ans++;                  //獨立集點個數加1

            S[t] = true;
            S[father[t]] = true;
            //標記當前點、當前結點的父節點都被覆蓋
        }
    }
    return ans;
}