說在前面

並沒有什麼想說的，但是要保持格式

題目

題目大意

給出一個N個節點的樹，求出樹的最小路徑覆蓋
路徑不能有公共點，即不能相交

輸入輸出格式

輸入格式：
第一行一個整數T，表示資料組數
對於每組：第一行一個整數N表示點數。接下來N-1行，每行兩個數字u，v描述邊

輸出格式：
每組資料輸出一行一個整數，表示答案

解法

先說DP做法

如果所有點都獨立算作一條路徑，那麼路徑條數為N。在這個基礎之上，每選一條邊去連線兩個度數不為2的節點，相當於合併了兩條鏈，因此條數-1。現在就是需要求最多能選中多少條邊
很顯然的，在任何一種路徑覆蓋方案中，每個點的度數只會是0,1,2。於是定義dp[u][0/1/2]表示只考慮子樹的情況下，u號節點度數為0/1/2時，最多能選多少條邊。然後可以發現dp[u][0]其實就是max（dp[son][0/1/2]）之和，而葉結點的dp[u][0]是0，因此度數為0這種情況對最終答案沒有貢獻。然後還可以發現，只有dp[son][0/1]可以轉移到dp[u]，而轉移完成之後，dp[son][0/1]就再也用不上了，因此實際上可以把dp[u][0]與dp[u][1]合併。

那麼定義出狀態：dp[u][1/2]表示，u號節點所在鏈沒有終止（度數小於2）/已經終止（度數為2）時，子樹選擇邊數的最大值。轉移是顯然的，分當前點不與子節點連線（度數為0，也就是初值），與一個子節點連線（度數為1），與兩個子節點連線（度數為2）三種情況。細節可以自行思考，很簡單，程式碼也很短

於是貪心做法…

可以發現，當前點如果可以和子節點連線，那麼一定是連線最優，然後直接貪即可

下面是自帶大常數的程式碼

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace
 
 std ;

short T , N , tp , head[10005] , dp[10005][3] , fa[10005] ;
struct Path{
    short pre , to ;
}p[20005] ;

short size_of_short = sizeof( short ) ;
void clear(){
    tp = 0 ;
    memset( head + 1 , 0 , N * size_of_short ) ;
}

void In( short t1 , short t2 ){
    p[++tp].pre = head[t1] ;
    p[ head[t1] = tp ].to = t2 ;
}

void
 
 dfs( short u ){
    short sum = 0 , tmp = 0 ;
    for( short i = head[u] ; i ; i = p[i].pre ){
        short v = p[i].to ;
        if( v == fa[u] ) continue ;
        fa[v] = u , dfs( v ) ;
        if( dp[v][1] < dp[v][2] ) sum += dp[v][2] ;
        else{
            tmp ++ ;
            sum += dp[v][1] ;
        }
    }
    dp[u][1] = dp[u][2] = sum ;
    if( tmp >= 1 ) dp[u][1] ++ ;
    if( tmp >= 2 ) dp[u][2] += 2 ;
}

inline void read_( short &x ){
    x = 0 ;
    char ch = getchar() ;
    while( ch < '0' || ch > '9' ) ch = getchar() ;
    while( ch >='0' && ch <='9' ) x = (x<<1)+(x<<3)+ch-'0' , ch = getchar() ;
}

int main(){
    scanf( "%hd" , &T ) ;
    while( T -- ){
        scanf( "%hd" , &N ) ;
        clear() ;
        for( short i = 1 , u , v ; i < N ; i ++ ){
            read_( u ) , read_( v ) ;
            In( u , v ) ; In( v , u ) ;
        }
        dfs( 1 ) ;
        printf( "%hd\n" , N - max( dp[1][2] , dp[1][1] ) ) ;
    }
}