//Tanisha Pareek.
// a=97, z=122, A=65, Z=90, '0'-48, '9'-57

#include <bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>

using namespace __gnu_pbds;
using namespace std;

#define pb push_back

typedef long long ll;
typedef vector<ll> vll;
typedef tree<ll, null_type, less<int>, rb_tree_tag,tree_order_statistics_node_update> pbds; // find_by_order(k)--(returns iterator of ele. at index k), order_of_key(k)--(returns index of k if k was present in set.)
typedef tree<ll, null_type, less_equal<int>, rb_tree_tag,tree_order_statistics_node_update> multipbds;

//--CONSTANTS--
const ll mod = 1e9 + 7;

//--USEFUL FUNCTIONS--
bool    isPalindrome(string str){ll low = 0,high = str.length() - 1;while (low < high){if (str[low] != str[high])return false;low++,high--;}return true;}
bool    isPrime(ll n){for(ll i=2;(i*i)<=n;i++){if((n%i) == 0) return false;}return true;}
ll      highestSmallerPower(ll num, ll p){ll cnt=0,curr=1;while((curr*p)<=num) curr*=p,cnt++;return cnt;} // gives largest power value(say x) such that p^x <= num
ll      binpow(ll num, ll p){ll ans=1;while(p>0){if(p&1) ans = ans*num;num = num*num;p/=2;}return ans;} // num^p
ll      modulerExpo(ll num,ll p,ll m){ll ans=1;num%=m;while(p){if(p&1) ans*=num;ans%=m;p = p>>1;num*=num;num%=m;}return ans;} // (num^p)%m
ll      phin(ll n){ll result = n;for(ll i=2;(i*i)<=n;i++){if(n%i == 0){while(n%i == 0) n/=i;result -= result/i;}}if(n>1) result -= (result/n);return result;}

// To find if two elements are from same component, just check their parent using dsu.
// To find no. of connected components, run a loop on all elements and find their parents. Maintain count of unique parents, that's the answer
// Loop exists when two elements are already in the same component and you are performing their union.
struct DSU {
    vll parent,sizz;
    DSU() {}
    DSU(ll n) {
        for(ll i=0;i<=n;i++) parent.push_back(i);
        sizz.assign(n+1,1);
    }

    ll find_set(ll v) {
        if(parent[v] == v) return v;
        return parent[v] = find_set(parent[v]);
    }

    void union_set(ll u,ll v) {
        u = find_set(u);
        v = find_set(v);

        if(v == u) return;

        if(sizz[u] > sizz[v]) swap(u,v);
        parent[u] = v;
        sizz[v] += sizz[u];
    }
};

// ---- Solution ----

ll cal(vll &childs, map<ll,vll> &tree, vll &visited, ll root)
{
    visited[root]=1;
    for(auto i:tree[root])
    {
        if(visited[i] == 1) continue;
        childs[root] += (1+cal(childs,tree,visited,i));
    }
    return childs[root];
}

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
    #endif

    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    ll t;
    cin>>t;
    while(t--)
    {
        ll n;
        cin>>n;
        map<ll,vll> tree;
        ll ui,vi;
        for(ll i=0;i<(n-1);i++)
        {
            cin>>ui>>vi;
            // if(ui>vi) swap(ui,vi);
            tree[ui].pb(vi);
            tree[vi].pb(ui);
        }

        vll childs((n+1),0);
        vll visited((n+1),0);
        visited[0]=1;
        cal(childs,tree,visited,1);

        // for(auto i:tree)
        // {
        //     cout<<"i:"<<i.first<<": ";
        //     for(auto x:i.second) cout<<x<<" ";
        //     cout<<"\n";
        // }
        // for(ll i=1;i<=n;i++) cout<<"i:"<<i<<" -> "<<childs[i]<<"\n";

        ll ans=0;
        ll root = 1,par=-1;
        while(1)
        {
            if(tree[root].size() == 1)
            {
                if(childs[root] == 0) break;
                ans += (childs[root]-1);
                break;
            }
            else if(tree[root].size()==2)
            {
                ll val1 = tree[root][0];
                ll val2 = tree[root][1];

                if(val1 == par)
                {
                    ans += childs[val2];
                    break;
                }
                else if(val2 == par)
                {
                    ans += childs[val1];
                    break;
                }
                else
                {
                    par=root;
                    if(childs[val1] > childs[val2])
                    {
                        ans += childs[val1];
                        root = val2;
                    }
                    else
                    {
                        ans += childs[val2];
                        root = val1;
                    }
                }
            }
            else
            {
                ll val1 = tree[root][0];
                ll val2 = tree[root][1];

                if(val1 == par) val1 = tree[root][2];
                else if(val2 == par) val2 = tree[root][2];

                par=root;
                if(childs[val1] > childs[val2])
                {
                    ans += childs[val1];
                    root = val2;
                }
                else
                {
                    ans += childs[val2];
                    root = val1;
                }
            }
        }
        cout<<ans<<"\n";
    }
    return 0;
}