Problem:
D: みゃんぱすーれつ - Myampus Sequence -
物語
みゃんぱすー．
ウチ，田舎の分校に通う小学一年生なん．
あんなー，今日の授業はプログラミングだったん．
みんな苦戦してたけど，まっつんのにぃにぃ，凄い勢いでタイピングしてたん．
さすが中三なんなー．
にぃにぃ，プログラムが完成してどこか行ってしまったん．
そんで，画面見たら，色んな数列が出力されてたん．
だんだん出力と同じような数列を書きたくなったん，ウチ，出力テキストに同じような数列をいくつも書き加えてたん．
そしたら，にぃにぃが戻ってきて，すごい怒られたん．
ウチ，にぃにぃの声初めて聞いたから，びっくりしたん．
でな，にぃにぃに謝ってプログラムを見せてもらったん．
プログラムが出力してたん，「みゃんぱすーれつ」いうん．
数列がみゃんぱすーれつか調べて，にぃにぃの機嫌を直したいん．
でも，ウチ，プログラミング初めてなん，教えてほしいのん．
問題
N
個の整数からなる数列と
M
個の関数からなるプログラムが与えられる．プログラムが開始されると
1
番目の関数を呼び出し，この関数の処理が終了すると，プログラムは終了する．また，
i
(
1 ≤ i ≤ M
) 番目の関数は，次のどちらか一方の処理を行い，関数の処理を終了する．
整数
a_i
を出力する．
b_i
(
1 ≤ b_i ≤ M
) 番目の関数を呼び出し，呼び出した関数の処理が終了したら，
c_i
(
1 ≤ c_i ≤ M
) 番目の関数を呼び出し，呼び出した関数の処理の終了を待つ．
どちらの処理を行うかは，処理の度にランダムに決定される．つまり，プログラムが開始されると1個の数列を出力して終了する．ここで，プログラムが出力する数列としてあり得るものを「みゃんぱすーれつ」と定義する．
与えられた数列がみゃんぱすーれつか判定せよ．
入力形式
入力は次の形式で与えられる．
N
x_1
...
x_N
M
a_1
b_1
c_1
...
a_M
b_M
c_M
1行目に，判定すべき数列の長さ
N
が与えられる．
2行目に，判定すべき整数列
x_1
,
x_2
, ...,
x_N
が順に与えられる．
3行目に，関数の個数
M
が与えられる．
i + 3
(
1 ≤ i ≤ M
) 行目に，
i
番目の関数の情報を表す
a_i
,
b_i
,
c_i
が順に与えられる．
入力は次の制約を満たす．
1 ≤ N ≤ 100
i = 1,
...
, N
に対して，
x_i
は
0 ≤ x_i ≤ 9
を満たす整数
1 ≤ M ≤ 10
i = 1,
...
, M
に対して，
a_i
は
0 ≤ a_i ≤ 9
を満たす整数
i = 1,
...
, M
に対して，
b_i
は
1 ≤ b_i ≤ M
を満たす整数
i = 1,
...
, M
に対して，
c_i
は
1 ≤ c_i ≤ M
を満たす整数
出力形式
与えれた数列がみゃんぱすーれつの場合には “Yes” と出力し，数列がみゃんぱすーれつではない場合には “No” と出力せよ．また，出力の最後に改行せよ．
入力例1
3
3 5 3
3
5 2 3
3 3 1
7 1 2
出力例1
Yes
次のようにプログラムが動作すると，与えられた数列を生成します．
プログラムが関数
1
を呼び出す．
関数
1
が関数
2
と関数
3
を順に呼び出す．
関数
2
が
3
を出力する．
関数
3
が関数
1
と関数
2
を順に呼び出す．
関数
1
が
5
を出力する．
関数
2
が
3
を出力する．
入力例2
10
9 9 9 9 9 9 9 9 9 9
4
6 2 3
7 3 1
8 1 2
9 2 1
出力例2
No
どのような処理を行っても，関数
4
を呼び出すことがないので，
9
を出力することができません．そのため，
9
を含む数列を出力することはできません．
入力例3
2
2 4
4
1 2 3
2 1 1
3 4 1
4 1 1
出力例3
No
このプログラムは，
2, 4, 1
のように，
2, 4
を含む数列を生成することがありますが，
2, 4
自体を生成することはありません．

Submitted solutions:

code_snippet: #include <bits/stdc++.h>
using namespace std;

int N, M;
int x[110], a[15], b[15], c[15];
int dp[15][110][110];

int solve(int idx, int l, int r) {
  assert(r - l > 0);

  int val = dp[idx][l][r];
  if(val >= 0) return val;

  val = 0;
  if(r - l == 1) {
    val = (x[l] == a[idx]);
    return dp[idx][l][r] = val;
  }
  else {
    // split
    for(int k=l+1; k<r; k++) {
      int vl = solve(b[idx], l, k);
      int vr = solve(c[idx], k, r);
      val |= (vl && vr);
    }
  }
  return dp[idx][l][r] = val;
}

int main() {
  cin >> N;
  for(int i=0; i<N; i++) {
    cin >> x[i];
  }

  cin >> M;
  for(int i=0; i<M; i++) {
    cin >> a[i] >> b[i] >> c[i];
    b[i]--; c[i]--;
  }
  
  memset(dp, -1, sizeof(dp));
  cout << (solve(0, 0, N) ? "Yes" : "No") << endl;
  return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3816
final_rank: 10

code_snippet: #include <bits/stdc++.h>
#define show(x) cerr << #x << " = " << x << endl
using namespace std;
template <typename Functor>
struct fix_type
{
    Functor functor;
    template <typename... Args>
    decltype(auto) operator()(Args&&... args) const& { return functor(functor, std::forward<Args>(args)...); }
};
template <typename Functor>
fix_type<typename std::decay<Functor>::type> fix(Functor&& functor) { return {std::forward<Functor>(functor)}; }
int main()
{
    int N;
    cin >> N;
    vector<int> x(N);
    for (int i = 0; i < N; i++) { cin >> x[i]; }
    int M;
    cin >> M;
    vector<vector<int>> to(M, vector<int>(2));
    vector<int> num(M);
    for (int i = 0; i < M; i++) {
        cin >> num[i] >> to[i][0] >> to[i][1];
        to[i][0]--, to[i][1]--;
    }
    using P = pair<int, vector<int>>;
    map<P, bool> memo;
    auto f = fix([&](auto&& self, const int node, const vector<int>& arr) -> bool {
        if (memo.find({node, arr}) != memo.end()) { return memo[{node, arr}]; }
        const int sz = arr.size();
        if (sz == 1) { return memo[{node, arr}] = (arr[0] == num[node]); }
        const int c1 = to[node][0], c2 = to[node][1];
        for (int i = 1; i <= sz - 1; i++) {
            if (self(self, c1, vector<int>{arr.begin(), arr.begin() + i}) and self(self, c2, vector<int>{arr.begin() + i, arr.end()})) { return memo[{node, arr}] = true; }
        }
        return memo[{node, arr}] = false;
    });
    cout << (f(0, x) ? "Yes" : "No") << endl;
}
accuracy: 1
time_ms: 310
memory_kb: 8472
final_rank: 12

code_snippet: #include <stdio.h>
#include <cmath>
#include <algorithm>
#include <cfloat>
#include <stack>
#include <queue>
#include <vector>
#include <string>
#include <iostream>
#include <set>
#include <map>
#include <time.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;


struct Info{
	int a,b,c;
};

struct Data{
	stack<int> FUNC;
	int sequence[100],index;
};

int N,M;
int table[101];
bool FLG;
Info info[10];


void recursive(Data data){

	if(FLG)return;
	int rest = N-data.index;

	if(rest == 0){
		if(data.FUNC.size() == 0){
			FLG = true;
		}
		return;
	}

	if(data.FUNC.size() == 0){
		return;
	}


	int current_func = data.FUNC.top();
	data.FUNC.pop();
	int work_table[data.FUNC.size()],index;
	for(index = 0; data.FUNC.empty() == false; index++){
		work_table[index] = data.FUNC.top();
		data.FUNC.pop();
	}

	if(info[current_func].a == table[data.index]){
		Data next_data;
		for(int i = 0; i < data.index; i++){
			next_data.sequence[i] = data.sequence[i];
		}
		next_data.sequence[data.index] = info[current_func].a;
		next_data.index = data.index+1;
		for(int i = index-1; i >= 0; i--){
			next_data.FUNC.push(work_table[i]);
		}
		recursive(next_data);
	}

	if(rest >= data.index+index+1){
		Data next_data;
		for(int i = 0; i < data.index; i++){
			next_data.sequence[i] = data.sequence[i];
		}
		next_data.index = data.index;
		for(int i = index-1; i >= 0; i--){
			next_data.FUNC.push(work_table[i]);
		}
		next_data.FUNC.push(info[current_func].c);
		next_data.FUNC.push(info[current_func].b);
		recursive(next_data);
	}
}

int main(){

	scanf("%d",&N);
	for(int i = 0; i < N; i++)scanf("%d",&table[i]);

	scanf("%d",&M);
	for(int i = 0; i < M; i++){
		scanf("%d %d %d",&info[i].a,&info[i].b,&info[i].c);
		info[i].b--;
		info[i].c--;
	}

	FLG = false;

	Data first;
	first.FUNC.push(0);
	first.index = 0;

	recursive(first);

	if(FLG){
		printf("Yes\n");
	}else{
		printf("No\n");
	}

	return 0;
}
accuracy: 0.18309859154929578
time_ms: 1790
memory_kb: 3352
final_rank: 13

code_snippet: #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for(int (i)=0;(i)<(int)(n);++(i))
#define all(x) (x).begin(),(x).end()
#define pb push_back
#define fi first
#define se second
#define dbg(x) cout<<#x" = "<<((x))<<endl
template<class T,class U> ostream& operator<<(ostream& o, const pair<T,U> &p){o<<"("<<p.fi<<","<<p.se<<")";return o;}
template<class T> ostream& operator<<(ostream& o, const vector<T> &v){o<<"[";for(T t:v){o<<t<<",";}o<<"]";return o;}

int n,m;
int x[100],a[10],b[10],c[10];

int dp[101][101][10];
int dfs(int l, int r, int f)
{
    if(dp[l][r][f]>=0) return dp[l][r][f];

    if(r-l==1) return (x[l]==a[f]);

    int ret = 0;
    for(int i=l+1; i<r; ++i) ret |= dfs(l,i,b[f])&dfs(i,r,c[f]);

    return dp[l][r][f]=ret;
}

int main()
{
    cin >>n;
    rep(i,n) cin >>x[i];
    cin >>m;
    rep(i,m)
    {
        cin >>a[i] >>b[i] >>c[i];
        --b[i];
        --c[i];
    }

    memset(dp,-1,sizeof(dp));
    string ans = "No";
    if(dfs(0,n,0)==1) ans = "Yes";
    cout << ans << endl;
    return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3616
final_rank: 9

code_snippet: #include <bits/stdc++.h>

using namespace std;

int N, M;
int x[100];
int a[10], b[10], c[10];

int dp[100][101][10];

int rec(int l, int r, int myan)
{
  if(~dp[l][r][myan]) return (dp[l][r][myan]);
  if(l + 1 == r) return (x[l] == a[myan]);
  bool ret = false;
  for(int m = l + 1; m < r && !ret; m++)
    ret |= rec(l, m, b[myan]) & rec(m, r, c[myan]);
  return (dp[l][r][myan] = ret);
}


int main()
{
  cin >> N;
  for(int i = 0; i < N; i++) {
    cin >> x[i];
  }
  cin >> M;
  for(int i = 0; i < M; i++) {
    cin >> a[i] >> b[i] >> c[i];
    --b[i];
    --c[i];
  }
  memset(dp, -1, sizeof(dp));
  if(rec(0, N, 0)) cout << "Yes" << endl;
  else cout << "No" << endl;
}
accuracy: 1
time_ms: 10
memory_kb: 3484
final_rank: 7

code_snippet: #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
#define rep(i,n) for(ll i=0;i<(ll)(n);i++)
#define all(a)  (a).begin(),(a).end()
#define pb push_back
#define INF (1e9+1)
//#define INF (1LL<<59)

int main(){
	int n;
	cin>>n;
	vector<int> v(n);
	rep(i,n)cin>>v[i];
	
	int m;
	cin>>m;
	vector<int> mp(m);
	vector<pii> call(m);
	rep(i,m){
		int b,c;
		cin>>mp[i]>>b>>c;
		b--,c--;
		call[i] = pii(b,c);
	}
	
	bool dp[100][100][10];
	memset(dp,0,sizeof(dp));
	
	rep(i,n){
		rep(j,mp.size()){
			if(v[i]==mp[j]){
				dp[i][i][j]=true;
			}
		}
	}
	
	for(int width = 2; width<=n; width++){
		for(int l = 0; l<n; l++){
			int r = l+width-1;
			if(r>=n)continue;
			for(int i=0;i<m;i++){
				int x,y;
				tie(x,y) = call[i];
				for(int p=l; p<=r-1; p++){
					dp[l][r][i] |= (dp[l][p][x] & dp[p+1][r][y]);
				}
			}
		}
	}
	if(dp[0][n-1][0])cout<<"Yes"<<endl;
	else cout<<"No"<<endl;
}
accuracy: 1
time_ms: 10
memory_kb: 3184
final_rank: 6

code_snippet: #include <bits/stdc++.h>

using namespace std;

int N, M;
int x[100];
int memo[110][110][10];
int a[10], b[10], c[10];

int rec(int L, int R, int m)
{
    if (R - L == 0) {
	return (x[L] == a[m] ? 1 : 2);
    }
    int &res = memo[L][R][m];
    if (res > 0) return res;
    res = 2;
    for (int i = L; i <= R; i++) {
	int d = rec(L, i, b[m]);
	int e = rec(i + 1, R, c[m]);
	if (d == 1 && e == 1) {
	    res = 1;
	    break;
	}
    }
    return res;
}

int main()
{
    cin >> N;
    for (int i = 0; i < N; i++) {
	cin >> x[i];
    }
    cin >> M;
    for (int i = 0; i < M; i++) {
	cin >> a[i] >> b[i] >> c[i];
	b[i]--; c[i]--;
    }
    memset(memo, 0, sizeof(memo));
    cout << (rec(0, N - 1, 0) == 1 ? "Yes" : "No") << endl;
    return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3580
final_rank: 8

code_snippet: #include <cstdio>
#include <iostream>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <bitset>
#include <numeric>
#include <limits>
#include <climits>
#include <cfloat>
#include <functional>
using namespace std;

vector<int> x;
vector<int> a, b, c;
vector<vector<vector<int> > > memo;

bool solve(int i, int j, int f)
{
    if(i == j)
        return x[i] == a[f];
    if(memo[i][j][f] != -1)
        return memo[i][j][f] == 1;

    for(int k=i; k<j; ++k){
        if(solve(i, k, b[f]) && solve(k+1, j, c[f])){
            memo[i][j][f] = 1;
            return true;
        }
    }

    memo[i][j][f] = 0;
    return false;
}

int main()
{
    int n;
    cin >> n;
    x.resize(n);
    for(int i=0; i<n; ++i)
        cin >> x[i];

    int m;
    cin >> m;
    a = b = c = vector<int>(m);
    for(int i=0; i<m; ++i){
        cin >> a[i] >> b[i] >> c[i];
        -- b[i];
        -- c[i];
    }

    memo.assign(n, vector<vector<int> >(n, vector<int>(m, -1)));
    if(solve(0, n-1, 0))
        cout << "Yes" << endl;
    else
        cout << "No" << endl;

    return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 1924
final_rank: 4

code_snippet: #include <bits/stdc++.h>
using namespace std;

struct data{
    int a, b, c;
};


int n, m;
vector<int> v;
vector<data> dv;

bool solve(){
    vector<int> va[11][11];
    bool dp[110][110][11];


    memset(dp,0,sizeof(dp));
    // for(int i=0;i<n;i++){
    //     for(int j=0;j<n;j++){
    //         for(int k=0;k<m;k++){
    //             dp[i][j][k] = false;
    //         }
    //     }
    // }

    for(int i=0;i<n;i++){
        for(int j=0;j<m;j++){
            if(dv[j].a == v[i]) {
                dp[i][i][j] = true;
            }
        }
    }

    for(int i=0;i<m;i++){
        va[dv[i].b][dv[i].c].push_back(i);
    }

    for(int kk=1;kk<n;kk++){
        for(int i=0;i<n-1;i++){
            int k = i + kk;
            if(i + kk >= n) break;
            for(int j=i;j<i+kk;j++){
                for(int g=0;g<m;g++){
                    for(int h=0;h<m;h++){
                        if(dp[i][j][g] && dp[j+1][k][h]){
                            for(int ii=0;ii<va[g][h].size();ii++){
                                dp[i][k][va[g][h][ii]] = true;
                            }
                        }
                    }
                }
            }
        }
    }

    return dp[0][n-1][0];
}

int main(){
    int a, b, c;
    while(cin >> n){
        v.clear();
        dv.clear();
        for(int i=0;i<n;i++){
            cin >> a;
            v.push_back(a);
        }
        cin >> m;
        for(int i=0;i<m;i++){
            cin >> a >> b >> c;
            b--; c--;
            dv.push_back((data){a, b, c});
        }
        cout << (solve() ? "Yes" : "No") << endl;
    }
}
accuracy: 1
time_ms: 30
memory_kb: 1348
final_rank: 1

code_snippet: #include <bits/stdc++.h>
using namespace std;

#define dump(...) cout<<"# "<<#__VA_ARGS__<<'='<<(__VA_ARGS__)<<endl
#define repi(i,a,b) for(int i=int(a);i<int(b);i++)
#define peri(i,a,b) for(int i=int(b);i-->int(a);)
#define rep(i,n) repi(i,0,n)
#define per(i,n) peri(i,0,n)
#define all(c) begin(c),end(c)
#define mp make_pair
#define mt make_tuple

typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef vector<string> vs;

template<typename T1,typename T2>
ostream& operator<<(ostream& os,const pair<T1,T2>& p){
	return os<<'('<<p.first<<','<<p.second<<')';
}

template<typename Tuple>
void print_tuple(ostream&,const Tuple&){}
template<typename Car,typename... Cdr,typename Tuple>
void print_tuple(ostream& os,const Tuple& t){
	print_tuple<Cdr...>(os,t);
	os<<(sizeof...(Cdr)?",":"")<<get<sizeof...(Cdr)>(t);
}
template<typename... Args>
ostream& operator<<(ostream& os,const tuple<Args...>& t){
	print_tuple<Args...>(os<<'(',t);
	return os<<')';
}

template<typename Ch,typename Tr,typename C>
basic_ostream<Ch,Tr>& operator<<(basic_ostream<Ch,Tr>& os,const C& c){
	os<<'[';
	for(auto i=begin(c);i!=end(c);++i)
		os<<(i==begin(c)?"":" ")<<*i;
	return os<<']';
}

constexpr int INF=1e9;
constexpr int MOD=1e9+7;
constexpr double EPS=1e-9;

int solve(int i,int l,int r,const vi& xs,const vi& as,const vi& bs,const vi& cs,vector<vvi>& memo)
{
	if(memo[i][l][r]!=-1) return memo[i][l][r];
	if(r-l==1)
		return memo[i][l][r]=(as[i]==xs[l]);
	repi(p,l+1,r)
		if(solve(bs[i],l,p,xs,as,bs,cs,memo) && solve(cs[i],p,r,xs,as,bs,cs,memo))
			return memo[i][l][r]=true;
	return memo[i][l][r]=false;
}

int main()
{
	for(int n;cin>>n && n;){
		vi xs(n);
		rep(i,n) cin>>xs[i];
		int m; cin>>m;
		vi as(m),bs(m),cs(m);
		rep(i,m) cin>>as[i]>>bs[i]>>cs[i],bs[i]--,cs[i]--;
		vector<vvi> memo(m,vvi(n+1,vi(n+1,-1)));
		cout<<(solve(0,0,n,xs,as,bs,cs,memo)?"Yes":"No")<<endl;
	}
}
accuracy: 1
time_ms: 10
memory_kb: 1524
final_rank: 2

code_snippet: #include<bits/stdc++.h>
#define REP(x,y,z) for(int x=y;x<=z;x++)
#define FORD(x,y,z) for(int x=y;x>=z;x--)
#define MSET(x,y) memset(x,y,sizeof(x))
#define FOR(x,y) for(__typeof(y.begin()) x=y.begin();x!=y.end();x++)
#define F first
#define S second
#define MP make_pair
#define PB push_back
#define SZ size()
#define M 105
void RI(){}
template<typename... T>
void RI( int& head, T&... tail ) {
    scanf("%d",&head);
    RI(tail...);
}
using namespace std;
typedef long long LL;
int n,m,in[M],a[M],b[M],c[M];
int dp[M][M][M];
int go(int x,int l,int r)
{
	int &res = dp[x][l][r];
	if(res!=-1) return res;
	if(l==r)
	{
		if(a[x]==in[l]) res=1;
		else res=0;
		return res;
	}

	res = 0;
	int rx,ry;
	//[l,i] [i+1,r]
	REP(i,l,r-1)
	{
		rx = go(b[x], l, i);
		ry = go(c[x], i+1, r);
		if(rx && ry)
		{
			res=1;
			break;
		}
	}
	return res;
}
int main()
{
	RI(n);
	REP(i,1,n) RI(in[i]);
	RI(m);
	REP(i,1,m) RI(a[i], b[i], c[i]);
	MSET(dp, -1);
	//
	//
	
	puts(go(1,1,n) ? "Yes":"No");
	return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 5692
final_rank: 11

code_snippet: #include <bits/stdc++.h>
using namespace std;
int x[101],a[10],b[10],c[10],u[101][101][10];

int dfs(int l, int r, int k) {
  if(u[l][r][k]!=-1) return u[l][r][k];
  if(l==r) return x[l]==a[k];
  int f=0;

  
  for(int i=l; i<r; i++) {
    f|=dfs(l,i,b[k])&dfs(i+1,r,c[k]);
  }
  u[l][r][k]=f;
  return f;
}

int main() {
  int n;
  cin >> n;
  for(int i=0; i<n; i++) {
    cin >> x[i];
    for(int j=0; j<n; j++) {
      for(int k=0; k<10; k++) u[i][j][k]=-1;
    }
  }
  int m;
  cin >> m;
  for(int i=0; i<m; i++) {
    cin >> a[i] >> b[i] >> c[i];
    b[i]--;
    c[i]--;
  }
  u[0][n-1][0]=dfs(0,n-1,0);
  if(u[0][n-1][0]) cout << "Yes" << endl;
  else cout << "No" << endl;
  return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 1564
final_rank: 3

code_snippet: #define _USE_MATH_DEFINES
#include <algorithm>
#include <cstdio>
#include <functional>
#include <iostream>
#include <cfloat>
#include <climits>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <time.h>
#include <vector>
using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> i_i;
typedef pair<ll, int> ll_i;
typedef pair<double, int> d_i;
typedef pair<ll, ll> ll_ll;
typedef pair<double, double> d_d;
struct edge { int u, v; ll w; };

ll MOD = 1000000007;
ll _MOD = 1000000009;
int INF = INT_MAX / 2;
double EPS = 1e-10;

bool f(int l, int r, int j, vector<int>& x, vector<int>& a, vector<int>& b, vector<int>& c, vector<vector<vector<int> > >& memo) {
	if (memo[l][r][j] != -1) return memo[l][r][j];
	if (r - l == 1 && x[l] == a[j]) return memo[l][r][j] = 1;
	for (int m = l + 1; m <= r - 1; m++)
		if (f(l, m, b[j], x, a, b, c, memo) && f(m, r, c[j], x, a, b, c, memo))
			return memo[l][r][j] = 1;
	return memo[l][r][j] = 0;
}

int main() {
	int N; cin >> N;
	vector<int> x(N);
	for (int i = 0; i < N; i++)
		cin >> x[i];
	int M; cin >> M;
	vector<int> a(M), b(M), c(M);
	for (int j = 0; j < M; j++) {
		cin >> a[j] >> b[j] >> c[j];
		b[j]--; c[j]--;
	}
	vector<vector<vector<int> > > memo(N + 1, vector<vector<int> >(N + 1, vector<int>(M, -1)));
	cout << (f(0, N, 0, x, a, b, c, memo) ? "Yes" : "No") << endl;
}
accuracy: 1
time_ms: 10
memory_kb: 1932
final_rank: 5