Language: C++

/*
                   _ooOoo_
                  o8888888o
                  88" . "88
                  (| -_- |)
                  O\  =  /O
               ____/`---'\____
             .'  \\|     |//  `.
            /  \\|||  :  |||//  \
           /  _||||| -:- |||||-  \
           |   | \\\  -  /// |   |
           | \_|  ''\---/''  |   |
           \  .-\__  `-`  ___/-. /
         ___`. .'  /--.--\  `. . ___
      ."" '<  `.___\_<|>_/___.'  >'"".
     | | :  `- \`.;`\ _ /`;.`/ - ` : | |
     \  \ `-.   \_ __\ /__ _/   .-` /  /
======`-.____`-.___\_____/___.-`____.-'======
                   `=---='
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
         ·ð×æ±£ÓÓ       ÓÀÎÞBUG
*/
//use readint!
#pragma GCC optimize(1)
#pragma G++ optimize(1)
#pragma GCC optimize(2)
#pragma G++ optimize(2)
#pragma GCC optimize(3)
#pragma G++ optimize(3)
#pragma GCC optimize(4)
#pragma G++ optimize(4)
#pragma GCC optimize(5)
#pragma G++ optimize(5)
#pragma GCC optimize(6)
#pragma G++ optimize(6)
#pragma GCC optimize(7)
#pragma G++ optimize(7)
#pragma GCC optimize(8)
#pragma G++ optimize(8)
#pragma GCC optimize(9)
#pragma G++ optimize(9)
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#include<map>
#include<iostream>
#include<iomanip>
//#include<conio.h>
#include<algorithm>
#include<vector>
#include<set>
#include<cmath>
#include<stdio.h>
#include<fstream>
#include<assert.h>
#include<time.h>
#include<queue>
#include<deque>
#include<stack>
#include<list>
//#include<windows.h>
#include<sstream>
#include<string.h>
#define mp make_pair
#define ll long long
#define all(v) v.begin(),v.end()
#define memset(a,b) memset(a,b,sizeof(a))
using namespace std;
const int INF=2147483647;
const double PI=3.1415926535897932384626;
const int maxn=10005;
struct bign{
    int d[maxn], len;
    inline void clean() { while(len > 1 && !d[len-1]) len--; }
    inline bign()          { memset(d, 0); len=1; }
    inline bign(int num)   { *this=num; }
    inline bign(char* num) { *this=num; }
    inline bign operator=(const char* num){
        memset(d, 0); len=strlen(num);
        for(int i=0; i<len; i++) d[i]=num[len-1-i] - '0';
        clean();
        return *this;
    }
    inline bign operator=(int num){
        char s[20]; sprintf(s, "%d", num);
        *this=s;
        return *this;
    }
    inline bign operator + (const bign& b){
        bign c=*this; int i;
        for (i=0; i<b.len; i++){
            c.d[i] +=b.d[i];
            if (c.d[i] > 9) c.d[i]%=10, c.d[i+1]++;
        }
        while (c.d[i] > 9) c.d[i++]%=10, c.d[i]++;
        c.len=max(len, b.len);
        if (c.d[i] && c.len<=i) c.len=i+1;
        return c;
    }
	inline bign operator - (const bign& b){
        bign c=*this; int i;
        for (i=0; i<b.len; i++){
            c.d[i] -=b.d[i];
            if (c.d[i]<0) c.d[i]+=10, c.d[i+1]--;
        }
        while (c.d[i]<0) c.d[i++]+=10, c.d[i]--;
        for(i=c.len-1;i>0;i--) if(c.d[i]!=0) break;
        c.len=i+1;
//      c.clean();
        return c;
    }
    inline bign operator * (const bign& b)const{
        int i, j; bign c; c.len=len + b.len;
        for(j=0; j<b.len; j++) for(i=0; i<len; i++)
            c.d[i+j] +=d[i] * b.d[j];
        for(i=0; i<c.len-1; i++)
            c.d[i+1] +=c.d[i]/10, c.d[i] %=10;
        c.clean();
        return c;
    }
    inline bign operator / (const bign& b){
        int i, j;
        bign c=*this, a=0;
        for (i=len - 1; i >=0; i--)
        {
            a=a*10 + d[i];
            for (j=0; j<10; j++) if (a<b*(j+1)) break;
            c.d[i]=j;
            a=a - b*j;
        }
        c.clean();
        return c;
    }
    inline bign operator % (const bign& b){
        int i, j;
        bign a=0;
        for (i=len-1;i>=0;i--){
            a=a*10 + d[i];
            for (j=0; j<10; j++) if (a<b*(j+1)) break;
            a=a - b*j;
        }
        return a;
    }
    inline bign operator += (const bign& b){
        *this=*this + b;
        return *this;
    }
    inline bign operator *= (const bign& b){
    	*this=*this * b;
    	return *this;
	}
	inline bign operator -= (const bign& b){
		*this=*this - b;
		return *this;
	}
	inline bign operator /= (const bign& b){
		*this=*this / b;
		return *this;
	}
    inline bool operator < (const bign& b) const{
        if(len !=b.len) return len<b.len;
        for(int i=len-1; i >=0; i--)
            if(d[i] !=b.d[i]) return d[i]<b.d[i];
        return false;
    }
    inline bool operator >(const bign& b) const{return b<*this;}
    inline bool operator<=(const bign& b) const{return !(b<*this);}
    inline bool operator>=(const bign& b) const{return !(*this<b);}
    inline bool operator!=(const bign& b) const{return b<*this || *this<b;}
    inline bool operator==(const bign& b) const{return !(b<*this) && !(b > *this);}
    inline string str() const{
        char s[maxn]={};
        for(int i=0; i<len; i++) s[len-1-i]=d[i]+'0';
        return s;
    }
};

inline istream& operator >>(istream& in, bign& x)
{
    string s;
    in>>s;
    x=s.c_str();
    return in;
}

inline ostream& operator << (ostream& out, const bign& x)
{
    out<<x.str();
    return out;
}
inline void write(ll x){
    if(x<0) putchar('-'),x=-x;
    if(x>9) write(x/10);
    putchar(x%10+'0');
}
inline int pt(int a[],int l,int r){
	int p,i,j;
	p=a[l];
	i=l;
	j=r+1;
	for(;;){
		while(a[++i]<p) if(i>=r) break;
		while(a[--j]>p) if(j<=l) break;
		if(i>=j) break;
		else swap(a[i],a[j]);
	}
	if(j==l) return j;
	swap(a[l],a[j]);
	return j;
}
inline void q_sort(int a[],int l,int r){
	int q;
	if(r>l){
		q=pt(a,l,r);
		q_sort(a,l,q-1);
		q_sort(a,q+1,r);
	}
}
inline void write(int x){
    if(x<0) putchar('-'),x=-x;
    if(x>9) write(x/10);
    putchar(x%10+'0');
}
inline void rd(long long &val){
    long long x=0;
    int f=1;
    char ch=getchar();
    while((ch<'0'||ch>'9')&&ch!='-') ch=getchar();
	if(ch=='-'){
		f=-1;
		ch=getchar();
	}
    while(ch>='0'&&ch<='9'){
        x=x*10+ch-'0';
        ch=getchar();
    }
    val=x*f;
}
inline void rd(int &val){
    int x=0;
    int f=1;
    char ch=getchar();
    while((ch<'0'||ch>'9')&&ch!='-') ch=getchar();
	if(ch=='-'){
		f=-1;
		ch=getchar();
	}
    while(ch>='0'&&ch<='9'){
        x=x*10+ch-'0';
        ch=getchar();
    }
    val=x*f;
}
inline void _write(int x){
	write(x);
	putchar(' ');
}
inline void print(int x){
	write(x);
	putchar('\n');
}
inline void _write(ll x){
	write(x);
	putchar(' ');
}
inline void print(ll x){
	write(x);
	putchar('\n');
}
struct PII{
	int first,second;
	PII(){}
	PII(int f, int s): first(f),second(s){}
	inline bool operator <(const PII& x)const{
		if(first!=x.first) return first<x.first;
		return second<x.second;
	}
	inline bool operator ==(const PII& x)const{
		return first==x.first and second==x.second;
	}
	inline bool operator >(const PII& x)const{
		if(first!=x.first) return first>x.first;
		return second>x.second;
	}
	inline bool operator !=(const PII& x)const{
		return first!=x.first and second!=x.second;
	}
};
ofstream out;
ifstream in;
inline string itos(int x){
	string rt="";
	while(x) rt=(char)(x%10+'0')+rt,x/=10;
	return rt;
}
clock_t __stt;
inline void TStart(){__stt=clock();}
inline void TReport(){printf("\nTaken Time : %.3lf sec\n",(double)(clock()-__stt)/CLOCKS_PER_SEC);}
int low[100005],up[100005],col[100005],n,k;
vector<int> v[100005];
int odd[100005];
int base_col;
bool use[100005];
vector<int> _v;
inline void dfs(int x){
//	cerr<<"XXX:    "<<x<<endl;
	int i,tx,ty,t;
	for(i=0;i<v[x].size();++i){
		t=v[x][i];
		tx=low[x]-1;
		ty=up[x]+1;
		if(max(tx,low[t])>min(ty,up[t])){
			puts("No");
			exit(0);
		}
		if(0tx>=low[t] and ty<=up[t]){
			low[t]=tx; 
			up[t]=ty;
			dfs(t);
		}else continue;
	}
}
inline void check(int x,int dist){
	if(use[x]) return;
	if(~odd[x]){
		if((base_col+dist)&1!=odd[x]){
//			cerr<<"AFDSFSDGG:    "<<base_col<<' '<<dist<<' '<<x<<endl;
			puts("No");
			exit(0);
		}
	}
	use[x]=1;
	for(int i=0;i<v[x].size();++i) check(v[x][i],dist+1);
}
inline void go(int x){
	if(use[x]) return;
	use[x]=1;
	col[x]=up[x];
	for(int i=0;i<v[x].size();++i) go(v[x][i]);
}
int main(){
//	ios_base::sync_with_stdio(false);
	int i,j;
	#ifdef LOCAL
        TStart();
    #endif
    rd(n);
    int x,y;
    for(i=0;i<n-1;++i){
    	rd(x),rd(y);
		--x,--y;
		v[x].push_back(y); 
		v[y].push_back(x);
	}
	rd(k);
	int t;
	memset(odd,-1);
	for(i=0;i<n;++i) low[i]=-INF,up[i]=INF;
	for(i=0;i<k;++i){
		rd(x),rd(y);
		--x;
		col[x]=y;
		low[x]=up[x]=y;
		t=x;
		_v.push_back(x);
		odd[x]=y&1;
	}
//	cerr<<"\n";
//	for(i=0;i<n;++i) cerr<<odd[i]<<' ';
//	cerr<<'\n';
	base_col=odd[t];
	check(t,0);
	for(i=0;i<_v.size();++i) dfs(_v[i]);
//	for(i=0;i<n;++i) cout<<i<<" :  ",_write(low[i]),print(up[i]);
	puts("Yes");
	memset(use,0);
	go(t);
	for(i=0;i<n;++i) print(col[i]);
//	putchar('\n');
    #ifdef LOCAL
        TReport();
    #endif
}

Compiler output:
a.cc:42:51: warning: bad option '-funsafe-loop-optimizations' to pragma 'optimize' [-Wpragmas]
   42 | #pragma GCC optimize("-funsafe-loop-optimizations")
      |                                                   ^
a.cc:44:39: warning: bad option '-fwhole-program' to pragma 'optimize' [-Wpragmas]
   44 | #pragma GCC optimize("-fwhole-program")
      |                                       ^
a.cc:54:41: warning: bad option '-fcse-skip-blocks' to pragma 'optimize' [-Wpragmas]
   54 | #pragma GCC optimize("-fcse-skip-blocks")
      |                                         ^
a.cc:75:41: warning: bad option '-fstrict-overflow' to pragma 'optimize' [-Wpragmas]
   75 | #pragma GCC optimize("-fstrict-overflow")
      |                                         ^
a.cc:109:23: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
  109 |     inline void clean() { while(len > 1 && !d[len-1]) len--; }
      |                       ^
a.cc:109:23: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
a.cc:109:23: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
a.cc:109:23: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
a.cc:110:17: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
  110 |     inline bign()          { memset(d, 0); len=1; }
      |                 ^
a.cc:110:17: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
a.cc:110:17: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
a.cc:110:17: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
a.cc:111:24: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
  111 |     inline bign(int num)   { *this=num; }
      |                        ^
a.cc:111:24: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
a.cc:111:24: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
a.cc:111:24: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
a.cc:112:26: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
  112 |     inline bign(char* num) { *this=num; }
      |                          ^
a.cc:112:26: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
a.cc:112:26: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
a.cc:112:26: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
a.cc:113:42: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
  113 |     inline bign operator=(const char* num){
      |                                          ^
a.cc:113:42: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
a.cc:113:42: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
a.cc:113:42: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
a.cc:119:34: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
  119 |     inline bign operator=(int num){
      |                                  ^
a.cc:119:34: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
a.cc:119:34: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
a.cc:119:34: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
a.cc:124:42: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
  124 |     inline bign operator + (const bign& b){
      |                                          ^
a.cc:124:42: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
a.cc:124:42: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
a.cc:124:42: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
a.cc:135:46: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
  135 |         inline bign operator - (const bign& b){
      |                                              ^
a.cc:135:46: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
a.cc:135:46: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
a.cc:135:46: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
a.cc:147:43: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
  147 |     inline bign operator * (const bign& b)const{
      |                                           ^~~~~
a.cc:147:43: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
a.cc:147:43: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
a.cc:147:43: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
a.cc:156:42: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
  156 |     inline bign operator / (const bign& b){
      |                                          ^
a.cc:156:42: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
a.cc:156:42: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
a.cc:156:42: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
a.cc:169:42: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
  169 |     inline bign operator % (const bign& b){
      |                                          ^
a.cc:169:42: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
a.cc:169:42: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
a.cc:169:42: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
a.cc:179:43: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
  179 |     inline bign operator += (const bign& b){
      |                                           ^
a.cc:179:43: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
a.cc:179:43: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
a.cc:179:43: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
a.cc:183:43: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
  183 |     inline bign operator *= (const bign& b){
      |                                           ^
a.cc:183:43: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
a.cc:183:43: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
a.cc:183:43: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
a.cc:187:47: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
  187 |         inline bign operator -= (const bign& b){
      |                                               ^
a.cc:187:47: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
a.cc:187:47: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
a.cc:187:47: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
a.cc:191:47: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
  191 |         inline bign operator /= (const bign& b){
      |                                               ^
a.cc:191:47: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
a.cc:191:47: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
a.cc:191:47: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
a.cc:195:44: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
  195 |     inline bool operator < (const bign& b) const{
      |                                            ^~~~~
a.cc:195:44: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
a.cc:195:44: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
a.cc:195:44: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
a.cc:201:43: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
  201 |     inline bool operator >(const bign& b) const{return b<*this;}
      |                                           ^~~~~
a.cc:201:43: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
a.cc:201:43: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
a.cc:201:43: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
a.cc:202:43: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
  202 |     inline bool operator<=(const bign& b) const{return !(b<*this);}
      |                                           ^~~~~
a.cc:202:43: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
a.cc:202:43: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
a.cc:202:43: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
a.cc:203:43: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
  203 |     inline bool operator>=(const bign& b) const{return !(*this<b);}
      |                                           ^~~~~
a.cc:203:43: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
a.cc:203:43: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
a.cc:203:43: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
a.cc:204:43: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
  204 |     inline bool operator!=(const bign& b) const{return b<*this || *this<b;}
      |                                           ^~~~~
a.cc:204:43: warning: bad option '-fwhole-program' to attribute 'op