pub use __cargo_equip::prelude::*;

use algebraic::{algebra, monoid};
#[allow(unused_imports)]
use proconio::{
    input,
    marker::{Bytes, Chars, Usize1},
};
use union_find_component_sum::UnionFindComponentSum;

algebra!(M, usize);
monoid!(M, 0, |a, b| a ^ b);

fn main() {
    input! {
        n: usize,
        mut p: [Usize1; n - 1],
        s: Bytes,
        m: usize,
        uv: [(Usize1, Usize1); m],
    }
    p.insert(0, !0);
    let mut a = vec![0; n];
    for i in 1..n {
        let x = (s[i - 1] == b'#') as usize;
        a[i] = x;
        a[p[i]] ^= x;
    }
    let mut uf = UnionFindComponentSum::<M>::new(n, &a);
    for &(u, v) in &uv {
        uf.merge(u, v);
    }
    println!(
        "{}",
        if (0..n).all(|i| uf.sum(i) == 0) {
            "Yes"
        } else {
            "No"
        }
    );
}

// The following code was expanded by `cargo-equip`.

///  # Bundled libraries
/// 
///  - `algebraic 0.1.0 (path+████████████████████████████████████████████████████████)`                                    published in **missing** licensed under `CC0-1.0` as `crate::__cargo_equip::crates::algebraic`
///  - `union-find-component-sum 0.1.0 (path+████████████████████████████████████████████████████████████████████████████)` published in **missing** licensed under `CC0-1.0` as `crate::__cargo_equip::crates::union_find_component_sum`
#[cfg_attr(any(), rustfmt::skip)]
#[allow(unused)]
mod __cargo_equip {
    pub(crate) mod crates {
        pub mod algebraic {pub use crate::__cargo_equip::macros::algebraic::*;pub trait Algebra{type S;}pub trait Act:Algebra{type X;fn act(f:&Self::S,x:&Self::X)->Self::X;}pub trait Monoid:Algebra{fn e()->Self::S;fn op(x:&Self::S,y:&Self::S)->Self::S;}pub trait Group:Monoid{fn inv(x:&Self::S)->Self::S;}pub trait Zero{fn zero()->Self;fn is_zero(&self)->bool;}pub trait One{fn one()->Self;fn is_one(&self)->bool;}#[macro_export]macro_rules!__cargo_equip_macro_def_algebraic_algebra{($ident:ident,$ty:ty)=>{#[derive(Clone)]enum$ident{}impl$crate::__cargo_equip::crates::algebraic::Algebra for$ident{type S=$ty;}};}macro_rules!algebra{($($tt:tt)*)=>(crate::__cargo_equip_macro_def_algebraic_algebra!{$($tt)*})}#[macro_export]macro_rules!__cargo_equip_macro_def_algebraic_act{($ident:ident,$tar:ty,$act:expr)=>{impl$crate::__cargo_equip::crates::algebraic::Act for$ident{type X=$tar;#[inline]fn act(f:&Self::S,x:&Self::X)->Self::X{$act(f,x)}}};}macro_rules!act{($($tt:tt)*)=>(crate::__cargo_equip_macro_def_algebraic_act!{$($tt)*})}#[macro_export]macro_rules!__cargo_equip_macro_def_algebraic_monoid{($ident:ident,$e:expr,$op:expr)=>{impl$crate::__cargo_equip::crates::algebraic::Monoid for$ident{#[inline]fn e()->Self::S{$e}#[inline]fn op(x:&Self::S,y:&Self::S)->Self::S{$op(x,y)}}};}macro_rules!monoid{($($tt:tt)*)=>(crate::__cargo_equip_macro_def_algebraic_monoid!{$($tt)*})}#[macro_export]macro_rules!__cargo_equip_macro_def_algebraic_group{($ident:ident,$e:expr,$op:expr,$inv:expr)=>{impl$crate::__cargo_equip::crates::algebraic::Monoid for$ident{#[inline]fn e()->Self::S{$e}#[inline]fn op(x:&Self::S,y:&Self::S)->Self::S{$op(x,y)}}impl$crate::__cargo_equip::crates::algebraic::Group for$ident{#[inline]fn inv(x:&Self::S)->Self::S{$inv(x)}}};}macro_rules!group{($($tt:tt)*)=>(crate::__cargo_equip_macro_def_algebraic_group!{$($tt)*})}macro_rules!impl_zero_one{($($t:ty)*)=>{$(impl$crate::__cargo_equip::crates::algebraic::Zero for$t{fn zero()->Self{0}fn is_zero(&self)->bool{*self==0}}impl$crate::__cargo_equip::crates::algebraic::One for$t{fn one()->Self{1}fn is_one(&self)->bool{*self==1}})*};}impl_zero_one!(usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128);}
        pub mod union_find_component_sum {use crate::__cargo_equip::preludes::union_find_component_sum::*;use std::mem::swap;use algebraic::Monoid;#[derive(Clone)]pub struct UnionFindComponentSum<M>where M:Monoid,M::S:Clone,{par:Vec<i32>,sum:Vec<M::S>,cnt:usize,}impl<M>UnionFindComponentSum<M>where M:Monoid,M::S:Clone,{pub fn new(n:usize,a:&[M::S])->Self{Self{par:vec![-1;n],sum:a.to_vec(),cnt:n,}}pub fn len(&self)->usize{self.par.len()}pub fn count(&self)->usize{self.cnt}pub fn merge(&mut self,x:usize,y:usize)->bool{let mut x=self.leader(x);let mut y=self.leader(y);if x==y{return false;}self.cnt-=1;if-self.par[x]< -self.par[y]{swap(&mut x,&mut y);}self.par[x]+=self.par[y];self.sum[x]=M::op(&self.sum[x],&self.sum[y]);self.par[y]=x as i32;true}pub fn leader(&mut self,x:usize)->usize{let mut v=x;while self.par[v]>=0{v=self.par[v]as usize;}let mut u=x;while self.par[u]>=0{let t=self.par[u]as usize;self.par[u]=v as i32;u=t;}u}pub fn same(&mut self,x:usize,y:usize)->bool{self.leader(x)==self.leader(y)}pub fn size(&mut self,x:usize)->usize{let x=self.leader(x);-self.par[x]as usize}pub fn groups(&mut self)->Vec<Vec<usize>>{let mut res=vec![vec![];self.len()];for x in 0..self.len(){res[self.leader(x)].push(x);}res.into_iter().filter(|g|g.len()>0).collect()}pub fn sum(&mut self,x:usize)->M::S{let x=self.leader(x);self.sum[x].clone()}}}
    }

    pub(crate) mod macros {
        pub mod algebraic {pub use crate::{__cargo_equip_macro_def_algebraic_act as act,__cargo_equip_macro_def_algebraic_algebra as algebra,__cargo_equip_macro_def_algebraic_group as group,__cargo_equip_macro_def_algebraic_monoid as monoid};}
        pub mod union_find_component_sum {}
    }

    pub(crate) mod prelude {pub use crate::__cargo_equip::crates::*;}

    mod preludes {
        pub mod algebraic {}
        pub mod union_find_component_sum {pub(in crate::__cargo_equip)use crate::__cargo_equip::crates::algebraic;}
    }
}