題意：求一顆無向樹的最小點覆蓋。 

  本來一看是最小點覆蓋，直接一下敲了二分圖求最小割，TLE。      

   樹形DP，叫的這麼玄乎，本來是線性DP是線上往前\後推，而樹形DP就是在樹上，由葉子結點狀態向根狀態推。

 dp[u][1/0]:表示，結點u，1：選擇，0,：不選。dp值是以改點為根（目前為止，dfs遍歷順序自然決定了樹的層）的已經選擇點數，自然開始時不知道，對每個點,初值dp[u][0]=0、

dp[u][1]=1，回溯的時候:

                  1:dp[u][1]+=min(dp[v][1],dp[v][0]);該節點選擇了，那麼子節點可選可不選。

                   2:dp[u][0]+=dp[v][1];該節點沒有選擇，則其子節點必需選擇。

#include<iostream>
#include<queue>
#include<stack>
#include<cstdio>
#include<vector>
using namespace std;
int n; 
vector<vector<int> >v(100010);
int vis[100010];
int dp[100010][2];          
inline int minn(int a,int b)
{
    if(a<b)return a;
    return b;
}
void dfs(int u)
{
    dp[u][0]=0;          //不放，0個
    dp[u][1]=1;         //放一個，
    for(int i=0;i<v[u].size();i++)
    {
        int vv=v[u][i];
        if(!vis[vv])
           {
               vis[vv]=1;
               dfs(vv);
          dp[u][0]+=dp[vv][1];          //回溯時加上
          dp[u][1]+=minn(dp[vv][1],dp[vv][0]);
           }
    }
}
int main()
{
    scanf("%d",&n);
    int tx,ty;
    for(int i=0;i<n-1;i++)
       {
           scanf("%d%d",&tx,&ty);
           v[tx].push_back(ty);
           v[ty].push_back(tx);
       }
       vis[1]=1;
       dfs(1);
    cout<<minn(dp[1][0],dp[1][1]);  //結果為根放與不放的狀態最小值
       return 0;
}
 

      666，求最優時候方案數，

     多一個DP方程即可。

#include<iostream>
#include<cstdio>
#include<vector>
using namespace std;
int n;
vector<vector<int> >v(100020);
int vis[100020];
struct state
{
    int light;
    int count;
};
state dp[100020][2];
inline int minn(int a,int b)
{
    if(a<b)return a;
    return b;
}
void dfs(int u)
{
    dp[u][0].light=0;          //不放，0個
    dp[u][1].light=1;         //放一個，
    dp[u][0].count=dp[u][1].count=1;
    for(int i=0;i<v[u].size();i++)
    {
        int vv=v[u][i];
        if(!vis[vv])
           {
               vis[vv]=1;
               dfs(vv);
          dp[u][0].light+=dp[vv][1].light;          //回溯時加上
          dp[u][1].light+=minn(dp[vv][1].light,dp[vv][0].light);

          dp[u][0].count= dp[u][0].count*dp[vv][1].count%10007;

         if(dp[vv][1].light<dp[vv][0].light)
           dp[u][1].count=dp[u][1].count*dp[vv][1].count%10007;

         else if (dp[vv][1].light>dp[vv][0].light)
           dp[u][1].count=dp[u][1].count*dp[vv][0].count%10007;

         else
           dp[u][1].count=dp[u][1].count*(dp[vv][0].count+dp[vv][1].count)%10007;

           }
    }
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
          int tx,ty;
         for(int i=0;i<=n;i++)
       {
           v[i].clear();vis[i]=0;
       }
       for(int i=0;i<n-1;i++)
       {
           scanf("%d%d",&tx,&ty);
           v[tx].push_back(ty);
           v[ty].push_back(tx);
        }
       vis[1]=1;
       dfs(1);
     int ans1=minn(dp[1][0].light,dp[1][1].light);  //結果為根放與不放的狀態最小值
     if(dp[1][0].light<dp[1][1].light)
     {
         printf("%d %d\n",ans1,dp[1][0].count);
     }
     else if(dp[1][0].light>dp[1][1].light)
     {
         printf("%d %d\n",ans1,dp[1][1].count);
     }
     else
     {
         int ans2= (dp[1][0].count%10007+dp[1][1].count%10007)%10007;
         printf("%d %d\n",ans1,ans2);
     }
    }
       return 0;
}