use std::io;
fn main(){
    let mut input = String::new();
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let t: usize = input.trim().parse().expect("Input is not an integer");
    for _i in 0..t {
        input.clear();
        io::stdin().read_line(&mut input).expect("Failed to read line");
        let n: usize = input.trim().parse().expect("Input is not an integer");
        let mut adj : Vec<Vec<usize>> = Vec::new();
        for _j in 0..(n+1) {
            adj.push(Vec::new());
        }
        for _j in 0..(n-1) {
            input.clear();
            io::stdin().read_line(&mut input).expect("Failed to read line");
            let params: Vec<usize> = input
                .trim()
                .split_whitespace()
                .map(|x| x.parse().expect("Not an integer"))
                .collect();
            
            let l = params[0];
            let r = params[1];
            adj[l].push(r);
            adj[r].push(l); 
        }
        input.clear();
        io::stdin().read_line(&mut input).expect("Failed to read line");
        let bytes = input.trim().as_bytes();
        let mut leaf_zero = 0;
        let mut leaf_one = 0;
        let mut leaf_unknown = 0;
        let mut total_unknown =0;
        for i in 1..(n+1) {
            if bytes[i-1] == b'?' {
                total_unknown += 1;
            }

            if adj[i].len() == 1 && i != 1 {
                if bytes[i-1] == b'?' {
                    leaf_unknown += 1;
                }else if  bytes[i-1] == b'0' {
                    leaf_zero += 1;
                }else{
                    leaf_one += 1;
                }
            }
        }
     //   println!("{:?}", adj);
      //  println!("leaf z {} leaf o {} leaf u {}", leaf_zero, leaf_one, leaf_unknown);
        let mut ans = 0;
        if bytes[0] != b'?' {
            if bytes[0] == b'1' {
                ans += leaf_zero;
                ans += (leaf_unknown+1) / 2;
            }else{
                ans += leaf_one;
                ans += (leaf_unknown +1)/ 2;
            }
        }else{
            let rem = total_unknown - leaf_unknown-1;
            if leaf_one != leaf_zero {
                if leaf_one > leaf_zero {
                    ans += leaf_one;
                }else{
                    ans += leaf_zero;
                }
                ans += leaf_unknown / 2;

            }else{
                ans += leaf_one;
                if rem %2 == 0 {
                    ans += leaf_unknown/2;
                }else{
                    if leaf_unknown %2 == 0 {
                        ans += leaf_unknown/2;
                    }else{
                        ans += 1 + (leaf_unknown/2);
                    }
                }
            }
        }
        println!("{ans}");
    }
}