//[Author]   tuxedcat
//[Date]     2023.03.28
//[File]     src/a.cpp
//[Library]  https://github.com/tuxedcat/pslib
#pragma GCC optimize("O3")
// #pragma GCC optimize("O3")
// #pragma GCC target("avx2")
#include <bits/stdc++.h>
#define _EXT_CODECVT_SPECIALIZATIONS_H 1
#define _EXT_ENC_FILEBUF_H 1
using namespace std;
#pragma GCC diagnostic ignored "-Wparentheses"
#define SYSCALL_ALLOWED 1
#if SYSCALL_ALLOWED
	#include <bits/extc++.h>
	#include <ext/rope>
#endif

#define int i64
using fp=double; //long double,__float128
#define COUT_FP 10
#define FP_EPS 1e-11

#define CPP20 1
#define DBG_SETW 3

#define fi first
#define se second
#define mkp make_pair
#define mkt make_tuple
#define lb lower_bound
#define ub upper_bound
#define bs binary_search
#define itos to_string
#define head(x) (x.begin())
#define tail(x) prev(x.end())
#define dbg(...) void(0)
#define dbgif(...) void(0)
#define dbg1(...) void(0)
#define dbg1if(...) void(0)
#define dbgprint(...) void(0)
#define dbgprintln(...) void(0)
using i64=long long;using u64=unsigned long long;using u32=unsigned;
using pint=pair<int,int>;using tint=tuple<int,int,int>;
template<class T>using Str=basic_string<T>;
template<class T,class CMP=less<>>using PQ=std::priority_queue<T,vector<T>,CMP>;

#if CPP20
template<class T>concept Printable=requires(T x){cout<<x;};
template<class T>concept NotPrintable=not Printable<T>;
template<class T>concept Iterable=requires(T x){x.begin();x.end();begin(x);end(x);};
#else
#define Printable class
#define NotPrintable class
#define Iterable class
#endif
//functions before include <arr.h>

//Math
#if !(CPP20)
	#define countl_zero(x) __builtin_clzll(x)
	#define popcount(x) __builtin_popcountll(x)
	#define bit_ceil(x) (1<<clg2(x))
#endif
#if CPP20
	#define sz ssize
#else
	template<class T>int sz(const T& x){return x.size();}
#endif
int fdiv(int a,int b){if(b<0)a=-a,b=-b;return (a>0)?a/b:(a-b+1)/b;}
int cdiv(int a,int b){if(b<0)a=-a,b=-b;return (a>0)?(a+b-1)/b:a/b;}
i64 flg2(u64 x){return 63-countl_zero(x);}
i64 clg2(u64 x){return x-1==0?0:64-countl_zero(x-1);}
int fsqrt(i64 n) {i64 i=1;while(i*i<=n)i++;return i-1;}
int csqrt(i64 n) {i64 i=1;while(i*i<n)i++;return i;}
template<class T>T sq(T x){return x*x;}
template<class T>constexpr T inf(){return numeric_limits<T>::max()/2;}
template<class T> [[deprecated("use optional")]] constexpr T nan(){return inf<T>()+1;}
#if CPP20
template<typename T> concept MemberInf=requires(T t){t.inf();};
template<typename T> concept MemberNan=requires(T t){t.nan();};
template<MemberInf T>T inf(){return T().inf();}
template<MemberNan T> [[deprecated("use optional")]] T nan(){return T().nan();}
#endif

//IO & misc
template<class...A>ostream& osprint(ostream& os, A...a){return ((os<<a),...);}
#define print(...) osprint(cout,__VA_ARGS__)
#define println(...) osprint(cout,__VA_ARGS__,'\n')
template<class T,class U>bool assmin(T& a,U&& b){return a>b?a=b,true:false;}
template<class T,class U>bool assmax(T& a,U&& b){return a<b?a=b,true:false;}
void MUST(bool expr){
#if DEBUG
	#include <csignal>
	if(!expr)
		raise(SIGINT);
#endif
}
#define ARG(...) __VA_ARGS__
#define func(RetT,fname,...) function<RetT(__VA_ARGS__)> fname=[&](__VA_ARGS__)->RetT
#define lam(expr,...) [&](__VA_ARGS__){return expr;}
#define lamp(expr,...) [](__VA_ARGS__){return expr;}

auto val2cmp(auto val){return [val](auto x, auto y){return mkp(val(x),x)<mkp(val(y),y);};}

template<class T, class P=vector<T>>
struct Arr:public P{
	Arr(){P::shrink_to_fit();}
	explicit Arr(signed n):P(n){}
	explicit Arr(signed n,T init):P(n,init){}
	Arr(initializer_list<T>il):P(il){}
	Arr(auto its, auto ite):P(its,ite){}
	inline T& operator[](signed i){return P::operator[](i<0?i+sz(*this):i);}
	const T& operator[](signed i)const{return P::operator[](i<0?i+sz(*this):i);}
	T& at(signed i){return *this[i];}
	const T& at(signed i)const{return *this[i];}
};
template<class... A> auto ARR(auto n,A&&... a)
{if constexpr(!sizeof...(a)) return n; else return Arr(n,ARR(a...));}

//Consts
// const fp pi=numbers::pi_v<fp>,eps=FP_EPS;
const fp pi=acos(-1),eps=FP_EPS;
const int dir4[4][2]={{0,1},{-1,0},{0,-1},{1,0}};
const int dir8[8][2]={{0,1},{-1,1},{-1,0},{-1,-1},{0,-1},{1,-1},{1,0},{1,1}};
//functions after include <arr.h>

template<class T>int argmin(const Arr<T>& a){return min_element(a.begin(),a.end())-a.begin();}
template<class T>int argmax(const Arr<T>& a){return max_element(a.begin(),a.end())-a.begin();}
Arr<int> permuinv(const Arr<int>& a){Arr<int> r(sz(a));for(int i=0;i<sz(a);i++)r[a[i]]=i;return r;}
template<class T,class U=Arr<int>>map<T,U> classify(const Arr<T>& a){
	map<T,U> r;
	for(int i=0;i<sz(a);i++)
		r[a[i]].push_back(i);
	return r;
}
#if CPP20

template<class T=int,class... Ts> requires (!Iterable<T>) tuple<T,Ts...> input(){
	T x; cin>>x;
	if constexpr (sizeof...(Ts)==0) return mkt(x);
	else return tuple_cat(mkt(x),input<Ts...>());
}
template<class T=int,int n>std::array<T,n> input(){
	std::array<T,n> a;
	for(auto&i:a)
		i=get<0>(input<T>());
	return a;
}
string input(string& str){ cin>>str; return str; }
template<class T> requires (!Iterable<T>) T& input(T& a){ cin>>a; return a;}
template<class T> requires Iterable<T> T& input(T& a){ for(auto&i:a)input(i); return a; }
#else
	#define input() [](){int x;cin>>x;return mkt(x);}()
	// #define input(n) [](){Arr<int> a(n);for(auto&i:a)cin>>i;return a;}()
#endif

//Pre-runs
auto __PR=(cout<<fixed<<setprecision(COUT_FP),0);
#if !(DEBUG)
auto __PR_NDB=(ios::sync_with_stdio(0),cin.tie(0),cout.tie(0));
#endif
#define endl '\n'//Remove it when interactive
#define CHECK_INPUT 1
#define TC 1
#define TC_OUT_PREFIX ""//"Case #",ti,": "
signed main(){
	void solve();
	for(int ti=1,t=TC;ti<=t;ti++)
		print(TC_OUT_PREFIX),
		solve();
#if CHECK_INPUT
	assert(cin.get()=='\n');
	assert(cin.get()==EOF);
#endif
}
void solve(){
	int n; cin>>n;
	Arr<Arr<tint>> g(n);
	for(int i=0;i<n-1;i++){
		int a,b,c,d; cin>>a>>b>>c>>d;
		a--,b--;
		g[a].emplace_back(b,c,d);
		g[b].emplace_back(a,d,c);
	}

	auto tsz=ARR(n,1);
	func(int,inittsz,int x,int p){
		for(auto [y,w,rw]:g[x])
			if(y!=p)
				tsz[x]+=inittsz(y,x);
		return tsz[x];
	};
	inittsz(0,0);
	
	auto dpf=ARR(n,n+1,inf<int>());
	// func(int,init0,int x,int p){
	// 	dpf[x][0]=0;
	// 	for(auto [y,w]:g[x])
	// 		if(y!=p)
	// 			dpf[x][0]+=init0(y,x)+w;
	// 	return dpf[x][0];
	// };
	// init0(0,0);
	// dbg(dpf);
	// func(int,init1,int x,int p){
	// 	int longest=0;
	// 	for(auto [y,w]:g[x])
	// 		if(y!=p)
	// 			longest=max(longest,init1(y,x)+w);
	// 	dpf[x][1]=dpf[x][0]-longest;
	// 	return longest;
	// };
	// init1(0,0);
	// dbg(dpf);

	//지금 dp정의가 선택/선택안함이 꼬였다..
	//dp[x][i]=x서브트리에서 i개 선택안할때 비용이라고 풀어보자.
	//NOTE:선택안한 리프는 비용이 듦
	//dp[x][i>=sz(x)] = 0개선택 = 모든 edge합
	//dp[x][i=sz(x)-1] = 1개선택 = 모든 edge합 - 제일 긴 경로값
	//
	//근데 이러면 infimal convolution꼴이랑 살짝 달라서 인덱스 조정을 위해 아래처럼 정의를 변형하자.
	//dp[x][i] = x서브트리에서 i개 선택할때 비용
	//dp[x][0] = 모든 edge합
	//dp[x][1] = 모든 edge합 - 제일 긴 경로값
	//dp[x][2] = ? dp[x][0~1]과아무 관계가 없는듯...
	//
	//처음의 정의를 사용해서 dp[x][0]을 구할 수 있을까? 있다.
	//dp[x][i]=x서브트리에서 i개 선택안할때 비용
	//dp[x][0~tsz[x]-leaf[x]] = 모든 리프 선택 = 0
	//dp[x][tsz[x]-leaf[x]+1] = 제일 가까운 리프 선택취소
	//복잡하니까 그냥 dp[x][0]=0만 둬도 될듯? 아래 점화식이 가능하면.
	//dp[x][y] = dp[L][k]+dp[R][y-1-k]+(k==tsz[L]?wL:0)+(y-1-k==tsz[R]?wR:0)
	//k+(y-1-k)=y-1 이지만 dp[R]을 평행이동하면 y로 맞춰줄 수 있다. 평행이동 필요한 슬로프트릭?
	func(void,f,int x,int p){
		auto dpnew=ARR(n+1,inf<int>());
		for(auto [y,w,rw]:g[x])
			if(y!=p)
				f(y,x);
		dpf[x][0]=0;
		dpf[x][1]=0;
		for(auto [y,w,rw]:g[x])
			if(y!=p){
				for(int i=0;i<=n;i++)
					for(int j=0;j<=n;j++)
						if(i+j<=n){
							int val=dpf[x][i]+dpf[y][j];
							if(j==tsz[y])
								val+=w;
							dpnew[i+j]=min(dpnew[i+j],val);
						}
				for(int i=0;i<=n;i++)
					dpf[x][i]=min(dpf[x][i],dpnew[i]);
				dbg(dpf);
			}
	};
	f(0,0);
	dbg(dpf);
	func(int,calc1,int x,int p,int pv){
		int ret=pv+dpf[x][tsz[x]];
		for(auto [y,w,rw]:g[x])
			if(y!=p)
				ret=min(ret,calc1(y,x,pv+dpf[x][tsz[x]]-dpf[y][tsz[y]]-w+rw));
		return ret;
	};
	int val1=calc1(0,0,0);
	int qn; cin>>qn;
	Arr<int> q;
	for(int i=0;i<qn;i++){
		int x; cin>>x;
		q.push_back(x);
		println(x==1?val1:dpf[0][n-x]);
	}
}