Problem:
消える数列、消えない数列
ただお君は頭の体操をするために、数列を使ったゲームをしています。このゲームでは、はじめに、１から９までの数字がランダムに並んだ列が与えられます。ただお君は、数列からその一部分を消していきます。ルールは、以下の通りです。
数列から、同じ数字が２つ以上並んでいる部分を適当に選ぶ。その部分を含み、連続して現れている同じ数字をすべて消す。
消した部分の右側に数列が残っていた場合は、それを左に詰めて、数列を１つにまとめる。
上の２つの操作を繰り返した結果、すべての数字が消えればゲームクリアとなる。
例えば、上の図のような 1,2,3,3,2,2,1,2,2 という数列の場合、
左から数えて、３番目、４番目の３を消すと 1,2,2,2,1,2,2
左から数えて、２番目から４番目の２を消すと 1,1,2,2
左から数えて、１番目と２番目の１を消すと 2,2
左から数えて、１番目と２番目の２を消すと、ゲームクリアとなります。
ただし、どのように数字を消してもクリアできない数列があります。たとえば、1,2,3,3,1,2 や 1,2,3,1,2,3 などの数列です。短い数列であれば、ただお君でもクリアできるかどうかがすぐに分かり、クリアできないと分かれば違う数列にチャレンジできますが、長い数列になるとそう簡単にはいきません。
与えられた数列が上のゲームをクリアできるかどうか判定するプログラムを作成せよ。
Input
入力は以下の形式で与えられる。
N
c
1
c
2
...
c
N
１行目の
N
(1 ≤
N
≤ 100) は、数列の長さを表す整数である。２行目には１つの空白で区切られた
N
個の整数
c
i
(1 ≤
c
i
≤ 9) が与えられる。
c
i
は数列の
i
番目の数字を示す。
Output
上に示されたルールで数列を消すことができる場合は「yes」、できない場合は「no」を出力する。
Sample Input 1
8
1 2 3 3 2 1 2 2
Sample Output 1
yes
Sample Input 2
7
1 2 2 1 1 3 3
Sample Output 2
yes
Sample Input 3
16
9 8 8 7 7 6 5 4 4 5 1 1 2 2 3 3
Sample Output 3
no
Sample Input 4
5
1 1 2 2 1
Sample Output 4
yes

Submitted solutions:

code_snippet: #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll myRand(ll B) { return (ull)rng() % B; }

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n;
    cin >> n;
    vector<int> c(n);
    for (int i = 0; i < n; i++) {
        cin >> c[i];
    }
    vector<vector<bool>> dp(n + 1, vector<bool>(n + 1));
    for (int i = 0; i <= n; i++) {
        dp[i][i] = true;
    }
    for (int i = 0; i < n - 1; i++) {
        if (c[i] == c[i + 1]) dp[i][i + 2] = true;
    }
    for (int i = 0; i < n - 2; i++) {
        if (c[i] == c[i + 1] and c[i + 1] == c[i + 2]) dp[i][i + 3] = true;
    }
    for (int len = 4; len <= n; len++) {
        for (int i = 0; i + len <= n; i++) {
            for (int j = i; j <= i + len; j++) {
                if (dp[i][j] and dp[j][i + len]) dp[i][i + len] = true;
            }
            for (int x = i; x < i + len; x++) {
                for (int y = x + 1; y < i + len; y++) {
                    if (c[x] == c[y]) {
                        if (dp[i][x] and dp[x + 1][y] and dp[y + 1][i + len]) {
                            dp[i][i + len] = true;
                        }
                    }
                }
            }
            for (int x = i; x < i + len; x++) {
                for (int y = x + 1; y < i + len; y++) {
                    if (c[x] != c[y]) continue;
                    for (int z = y + 1; z < i + len; z++) {
                        if (c[x] != c[z]) continue;
                        if (dp[i][x] and dp[x + 1][y] and dp[y + 1][z] and dp[z + 1][i + len]) {
                            dp[i][i + len] = true;
                        }
                    }
                }
            }
        }
    }
    if (dp[0][n]) {
        cout << "yes" << endl;
    } else {
        cout << "no" << endl;
    }
}
accuracy: 1
time_ms: 150
memory_kb: 3464
final_rank: 11

code_snippet: #include <iostream>
#include <algorithm>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <numeric>
#include <bitset>
#include <cmath>

static const int MOD = 1000000007;
using ll = long long;
using u32 = unsigned;
using u64 = unsigned long long;
using namespace std;

template<class T> constexpr T INF = ::numeric_limits<T>::max()/32*15+208;

template <class T, class U>
vector<T> make_v(U size, const T& init){ return vector<T>(static_cast<size_t>(size), init); }

template<class... Ts, class U>
auto make_v(U size, Ts... rest) { return vector<decltype(make_v(rest...))>(static_cast<size_t>(size), make_v(rest...)); }

template<class T> void chmin(T &a, const T &b){ a = (a < b ? a : b); }
template<class T> void chmax(T &a, const T &b){ a = (a > b ? a : b); }

int main() {
    int n;
    cin >> n;
    vector<int> v(n);
    for (auto &&i : v) scanf("%d", &i);
    auto dp = make_v(n, n+1, 10, (signed char)(-1));
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < 10; ++j) {
            dp[i][i+1][j] = 0;
        }
        dp[i][i+1][v[i]] = 1;
    }
    for (int l = 0; l < n; ++l) {
        int r = l;
        while(r < n && v[l] == v[r]) r++;
        for (int i = l+2; i < r; ++i) {
            dp[l][i][0] = dp[l][i][v[l]] =  1;
        }
    }
    auto dfs = [&](int l, int r, int x, auto &&f) -> signed char {
        if(~dp[l][r][x]) return dp[l][r][x];
        if(!x){
            for (int i = l+1; i < r; ++i) {
                for (int j = 0; j < 10; ++j) {
                    if(f(l, i, j, f) && f(i, r, j, f)) return dp[l][r][x] = 1;
                }
            }
        }else {
            for (int i = l+1; i < r; ++i) {
                if(f(l, i, 0, f) && f(i, r, x, f)) return dp[l][r][x] = 1;
                if(f(l, i, x, f) && f(i, r, 0, f)) return dp[l][r][x] = 1;
                if(f(l, i, x, f) && f(i, r, x, f)) return dp[l][r][x] = 1;
            }
        }
        return dp[l][r][x] = 0;
    };
    puts(dfs(0, n, 0, dfs) ? "yes" : "no");
    return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3788
final_rank: 1

code_snippet: #include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#include<string>
#include<map>
using namespace std;
int array1[105]={0};
bool dp[105][105][10],decide[105][105][10];
bool sec_dp(int l,int r,int c){
  //[l,r)
  if(decide[l][r][c]) return dp[l][r][c];
  decide[l][r][c]=true;
  if(r-l==2){
    if(c==0){
      return dp[l][r][c]=(array1[l]==array1[l+1]);
    }
    else return dp[l][r][c]=(array1[l]==c&&array1[l+1]==c);
  }
  if(r-l==1){
    return dp[l][r][c]=(c==array1[l]);
  }
  for(int i=l+1;i<r;i++){
    if(c==0){
      for(int j=0;j<10;j++){
        bool b1=sec_dp(l,i,0);
        bool b2=sec_dp(l,i,j);
        bool b3=sec_dp(i,r,0);
        bool b4=sec_dp(i,r,j);
      //  if(l==0&&r==4&&i==1&&j==1) cout<<(b1?"Y":"N")<<(b2?"Y":"N")<<(b3?"Y":"N")<<(b4?"Y":"N")<<endl;
      //  if(l==1&&r==4&&i==3&&j==1) cout<<(b1?"Y!":"N!")<<(b2?"Y":"N")<<(b3?"Y":"N")<<(b4?"Y":"N")<<endl;
        if((b1&&b3)||(b2&&b4)) {
      //    cout<<"ina"<<l<<" "<<r<<" "<<i<<" "<<c<<" "<<j<<endl;
          return dp[l][r][c]=true;
        }
      }
    }
    else{
      bool b1=sec_dp(l,i,0);
      bool b2=sec_dp(l,i,c);
      bool b3=sec_dp(i,r,0);
      bool b4=sec_dp(i,r,c);
      if((b2&&b4)||(b1&&b4)||(b2&&b3)){
  //      cout<<"yoc"<<l<<" "<<r<<" "<<i<<" "<<c<<endl;
        return dp[l][r][c]=true;
      }
    }
  }
  return dp[l][r][c]=false;
}
int main(){
  //while(1){
    int n;
    cin>>n;
    if(n==0) return 0;
    for(int i=0;i<105;i++){
      array1[i]=0;
      for(int j=0;j<105;j++){
        for(int k=0;k<10;k++){
          dp[i][j][k]=false;
          decide[i][j][k]=false;
        }
      }
    }
    for(int i=0;i<n;i++) cin>>array1[i];
    cout<<(sec_dp(0,n,0)?"yes":"no")<<endl;
//  }
}
accuracy: 1
time_ms: 40
memory_kb: 3332
final_rank: 7

code_snippet: #include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#include<string>
#include<map>
using namespace std;
int array1[105]={0};
bool dp[105][105][10],decide[105][105][10];
bool sec_dp(int l,int r,int c){
  //[l,r)
  if(decide[l][r][c]) return dp[l][r][c];
  decide[l][r][c]=true;
  if(r-l==2){
    if(c==0){
      return dp[l][r][c]=(array1[l]==array1[l+1]);
    }
    else return dp[l][r][c]=(sec_dp(l,l+1,c)&&sec_dp(r-1,r,c));
  }
  if(r-l==1){
    decide[l][r][c]=true;
    return dp[l][r][c]=(c==array1[l]);
  }
  for(int i=l+1;i<r;i++){
    if(c==0){
      for(int j=0;j<10;j++){
        bool b1=sec_dp(l,i,0);
        bool b2=sec_dp(l,i,j);
        bool b3=sec_dp(i,r,0);
        bool b4=sec_dp(i,r,j);
      //  if(l==0&&r==4&&i==1&&j==1) cout<<(b1?"Y":"N")<<(b2?"Y":"N")<<(b3?"Y":"N")<<(b4?"Y":"N")<<endl;
      //  if(l==1&&r==4&&i==3&&j==1) cout<<(b1?"Y!":"N!")<<(b2?"Y":"N")<<(b3?"Y":"N")<<(b4?"Y":"N")<<endl;
        if((b1&&b3)||(b2&&b4)) return dp[l][r][c]=(b1&&b3)||(b2&&b4);
      }
    }
    else{
      bool b1=sec_dp(l,i,0);
      bool b2=sec_dp(l,i,c);
      bool b3=sec_dp(i,r,0);
      bool b4=sec_dp(i,r,c);
      return dp[l][r][c]=(b2&&b4)||(b1&&b4)||(b2&&b3);
    }
  }
  decide[l][r][c]=true;
  return dp[l][r][c]=false;
}
int main(){
  //while(1){
    int n;
    cin>>n;
    if(n==0) return 0;
    for(int i=0;i<105;i++){
      array1[i]=0;
      for(int j=0;j<105;j++){
        for(int k=0;k<10;k++){
          dp[i][j][k]=false;
          decide[i][j][k]=false;
        }
      }
    }
    for(int i=0;i<n;i++) cin>>array1[i];
    cout<<(sec_dp(0,n,0)?"yes":"no")<<endl;
//  }
}
accuracy: 0.5375
time_ms: 10
memory_kb: 3328
final_rank: 16

code_snippet: #include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#include<string>
#include<map>
using namespace std;
int array1[105]={0};
bool dp[105][105][10],decide[105][105][10];
bool sec_dp(int l,int r,int c){
  //[l,r)
  if(decide[l][r][c]) return dp[l][r][c];
  decide[l][r][c]=true;
  if(r-l==2){
    if(c==0){
      return dp[l][r][c]=(array1[l]==array1[l+1]);
    }
    else return dp[l][r][c]=(sec_dp(l,l+1,c)&&sec_dp(r-1,r,c));
  }
  if(r-l==1){
    decide[l][r][c]=true;
    return dp[l][r][c]=(c==array1[l]);
  }
  for(int i=l+1;i<r;i++){
    for(int j=0;j<10;j++){
      bool b1=sec_dp(l,i,0);
      bool b2=sec_dp(l,i,j);
      bool b3=sec_dp(i,r,0);
      bool b4=sec_dp(i,r,j);
    //  if(l==0&&r==4&&i==1&&j==1) cout<<(b1?"Y":"N")<<(b2?"Y":"N")<<(b3?"Y":"N")<<(b4?"Y":"N")<<endl;
    //  if(l==1&&r==4&&i==3&&j==1) cout<<(b1?"Y!":"N!")<<(b2?"Y":"N")<<(b3?"Y":"N")<<(b4?"Y":"N")<<endl;
      if(c==0){
        if((b1&&b3)||(b2&&b4)) return dp[l][r][c]=(b1&&b3)||(b2&&b4);
      }
      else{
        if(c==j){
          return dp[l][r][c]=(b2&&b4)||(b1&&b4)||(b2&&b3);
        }
      }
    }
  }
  decide[l][r][c]=true;
  return dp[l][r][c]=false;
}
int main(){
  //while(1){
    int n;
    cin>>n;
    if(n==0) return 0;
    for(int i=0;i<105;i++){
      array1[i]=0;
      for(int j=0;j<105;j++){
        for(int k=0;k<10;k++){
          dp[i][j][k]=false;
          decide[i][j][k]=false;
        }
      }
    }
    for(int i=0;i<n;i++) cin>>array1[i];
    cout<<(sec_dp(0,n,0)?"yes":"no")<<endl;
//  }
}
accuracy: 0.5375
time_ms: 10
memory_kb: 3332
final_rank: 17

code_snippet: // #define _GLIBCXX_DEBUG // for STL debug (optional)
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <string>
#include <cstring>
#include <deque>
#include <list>
#include <queue>
#include <stack>
#include <vector>
#include <utility>
#include <algorithm>
#include <map>
#include <set>
#include <complex>
#include <cmath>
#include <limits>
#include <cfloat>
#include <climits>
#include <ctime>
#include <cassert>
#include <numeric>
#include <fstream>
#include <functional>
#include <bitset>
using namespace std;

#define debug(...) fprintf(stderr, __VA_ARGS__)
#define int long long int
 
template<typename T> void chmax(T &a, T b) {a = max(a, b);}
template<typename T> void chmin(T &a, T b) {a = min(a, b);}
template<typename T> void chadd(T &a, T b) {a = a + b;}
 
typedef pair<int, int> pii;
typedef long long ll;
 
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
const ll INF = 1001001001001001LL;
const ll MOD = 1000000007LL;

const int MAXN = 110;
int dp[MAXN][MAXN][MAXN], A[MAXN];

int solve(int l, int r, int prefix) {
    if(r - l == 0) return true;
    if(r - l == 1) return prefix >= 2;
    int &val = dp[l][r][prefix];
    if(val >= 0) return val;

    val = prefix >= 2 ? solve(l+1, r, 1) : false;
    for(int i=l+1; i<r; i++) {
        if(A[l] == A[i]) {
            val |= solve(l+1, i, 1) & solve(i, r, prefix + 1);
        }
    }

    /*
    if(val == true) {
        fprintf(stderr, "true: segment = [%lld, %lld), prefix = %lld\n", l, r, prefix);
    }
    */
    return val;
}

signed main() {
    int N; cin >> N;
    for(int i=0; i<N; i++) {
        cin >> A[i];
    }
    fill(dp[0][0], dp[N+1][0], -1);
    cout << (solve(0, N, 1) ? "yes" : "no") << endl;
    return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 12648
final_rank: 10

code_snippet: #include <bits/stdc++.h>
#define r(i,n) for(int i=0;i<n;i++)
using namespace std;
int n,a[111],dp[111][111][11];

int dfs(int l,int r,int x){
    if(l==r)return x==a[l];
    if(dp[l][r][x]!=-1)return dp[l][r][x];
    dp[l][r][x]=0;
    for(int i=l;i<r;i++){
        for(int j=0;j<10;j++){
            if(dfs(l,i,j)&&dfs(i+1,r,j)) dp[l][r][0]=1 , dp[l][r][j]=1;
            if(dfs(l,i,j)&&dfs(i+1,r,0)) dp[l][r][j]=1;
            if(dfs(l,i,0)&&dfs(i+1,r,j)) dp[l][r][j]=1;
        }
    }
    return dp[l][r][x];
}

int main(){
    memset(dp,-1,sizeof(dp));
    cin>>n;
    r(i,n)cin>>a[i];
    dfs(0,n-1,0);
    cout<<(dp[0][n-1][0]==1?"yes":"no")<<endl;
}
accuracy: 1
time_ms: 180
memory_kb: 3672
final_rank: 12

code_snippet: #include <bits/stdc++.h>
#define r(i,n) for(int i=0;i<n;i++)
using namespace std;
int n,a[111],dp[111][111][11];

int dfs(int l,int r,int x){
    if(l==r)return x==a[l];
    if(dp[l][r][x]!=-1)return dp[l][r][x];
    dp[l][r][x]=0;
    for(int i=l;i<r;i++){
        for(int j=0;j<10;j++){
            if(dfs(l,i,j)&&dfs(i+1,r,j)) dp[l][r][0]=1 , dp[l][r][j]=1;
            if(dfs(l,i,j)&&dfs(i+1,r,0)) dp[l][r][j]=1;
            if(dfs(l,i,0)&&dfs(i+1,r,j)) dp[l][r][j]=1;
        }
    }
    return dp[l][r][x];
}

int main(){
    memset(dp,-1,sizeof(dp));
    cin>>n;
    r(i,n)cin>>a[i];
    dfs(0,n-1,0);
    cout<<(dp[0][n-1][0]?"yes":"no")<<endl;
}
accuracy: 0.4375
time_ms: 180
memory_kb: 3664
final_rank: 19

code_snippet: #include <stdio.h>
const int N=1e2+10;
bool ans[N][N],went[N][N];
int a[N];
bool dp(int l,int r){
    if(l-r==1)return true;
    else if(r<l)return false;
    if(went[l][r])return ans[l][r];
    went[l][r]=true;
    if(r==l)return ans[l][r]=false;
    else if(r-l==1)return ans[l][r]=a[l]==a[r];
    else if(r-l==2)return ans[l][r]=a[l]==a[l+1]&&a[l]==a[r];
    else{
        for(int i=l;i<=r;i++)for(int j=i+1;j<=r;j++)if(a[i]==a[j]){
            ans[l][r]=dp(l,i-1)&&dp(i+1,j-1)&&dp(j+1,r);
            if(ans[l][r])return true;
        }
        for(int i=l;i<=r;i++)for(int j=i+1;j<=r;j++)if(a[i]==a[j])for(int k=j+1;k<=r;k++)if(a[j]==a[k]){
            ans[l][r]=dp(l,i-1)&&dp(i+1,j-1)&&dp(j+1,k-1)&&dp(k+1,r);
            if(ans[l][r])return true;
        }
        return ans[l][r]=false;
    }
}
int main(){
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++)scanf("%d",&a[i]);
    for(int i=0;i<n;i++)for(int j=i;j<n;j++)went[i][j]=false;
    if(dp(0,n-1))printf("yes\n");
    else printf("no\n");
}
accuracy: 1
time_ms: 60
memory_kb: 2692
final_rank: 8

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

#define DB(x) cout<<#x<<"="<<x<<endl

int N;
vector<int>c;
//[i,j)???k???????????§?????????(false:0 true:1)
int memo[123][123][12];
int dp(int i,int j,int k){
	if(memo[i][j][k]>=0){
		return memo[i][j][k];
	}
	int res = 0;
	assert(i < j);
	if(j - i == 1){
		if(k == c[i])res = 1;
	}else{
		if(k){
			for(int m = i + 1;m < j;++m){
				if((dp(i,m,k)&&dp(m,j,k)) || (dp(i,m,k)&&dp(m,j,0)) || (dp(i,m,0)&&dp(m,j,k))){
					res = 1;
				}
			}
		}else{
			for(int kk = 0;kk <= 9;++kk){
				for(int m = i + 1;m < j;++m){
					if((dp(i,m,kk)&&dp(m,j,kk))){
						res = 1;
					}
				}
			}
		}
	}
	return memo[i][j][k]=res;
}

int main(){
	cin >> N;
	for(int i=0;i<N;++i){
		int cc;cin >> cc;
		c.push_back(cc);
	}
	memset(memo,0xff,sizeof(memo));
	cout << (dp(0,N,0) ? "yes" : "no") << endl;
	return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 3820
final_rank: 3

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

#define DB(x) cout<<#x<<"="<<x<<endl

int N;
vector<int>c;
//[i,j)???k???????????§?????????(false:0 true:1)
int memo[100][100][10];
int dp(int i,int j,int k){
	if(memo[i][j][k]>=0){
		return memo[i][j][k];
	}
	int res = 0;
	assert(i < j);
	if(j - i == 1){
		if(k == c[i])res = 1;
	}else{
		if(k){
			for(int m = i + 1;m < j;++m){
				if((dp(i,m,k)&&dp(m,j,k)) || (dp(i,m,k)&&dp(m,j,0)) || (dp(i,m,0)&&dp(m,j,k))){
					res = 1;
				}
			}
		}else{
			for(int kk = 0;kk <= 9;++kk){
				for(int m = i + 1;m < j;++m){
					if((dp(i,m,kk)&&dp(m,j,kk))){
						res = 1;
					}
				}
			}
		}
	}
	return memo[i][j][k]=res;
}

int main(){
	cin >> N;
	for(int i=0;i<N;++i){
		int cc;cin >> cc;
		c.push_back(cc);
	}
	memset(memo,0xff,sizeof(memo));
	cout << (dp(0,N,0) ? "yes" : "no") << endl;
	return 0;
}
accuracy: 0.6
time_ms: 10
memory_kb: 3500
final_rank: 14

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

#define DB(x) cout<<#x<<"="<<x<<endl

int N;
vector<int>c;
//[i,j)???k???????????§?????????(false:0 true:1)
int memo[100][100][10];
int dp(int i,int j,int k){
	if(memo[i][j][k]>=0){
		return memo[i][j][k];
	}
	int res = 0;
	assert(i < j);
	if(j - i == 1){
		if(k == c[i])res = 1;
	}else{
		if(k){
			for(int m = i + 1;m < j;++m){
				if((dp(i,m,k)&&dp(m,j,k)) || (dp(i,m,k)&&dp(m,j,0)) || (dp(i,m,0)&&dp(m,j,k))){
					res = 1;
					break;
				}
			}
		}else{
			for(int kk = 0;kk <= 9;++kk){
				for(int m = i + 1;m < j;++m){
					if((dp(i,m,kk)&&dp(m,j,kk))){
						res = 1;
						break;
					}
				}
				if(res)break;
			}
		}
	}
	return memo[i][j][k]=res;
}

int main(){
	cin >> N;
	for(int i=0;i<N;++i){
		int cc;cin >> cc;
		c.push_back(cc);
	}
	memset(memo,0xff,sizeof(memo));
	cout << (dp(0,N,0) ? "yes" : "no") << endl;
	return 0;
}
accuracy: 0.6
time_ms: 10
memory_kb: 3496
final_rank: 13

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

#define DB(x) cout<<#x<<"="<<x<<endl

int N;
vector<int>c;
//[i,j)???k???????????§?????????(false:0 true:1)
int memo[100][100][10];
int dp(int i,int j,int k){
	if(memo[i][j][k]>=0){
		return memo[i][j][k];
	}
	int res = 0;
	assert(i < j);
	if(j - i == 1){
		if(k == c[i])res = 1;
	}else{
		if(k){
			for(int m = i + 1;m < j;++m){
				if((dp(i,m,k)&&dp(m,j,k)) || (dp(i,m,k)&&dp(m,j,0)) || (dp(i,m,0)&&dp(m,j,k))){
					res = 1;
					break;
				}
			}
		}else{
			for(int kk = 1;kk <= 9;++kk){
				for(int m = i + 1;m < j;++m){
					if((dp(i,m,kk)&&dp(m,j,kk)) || (dp(i,m,0)&&dp(m,j,0))){
						res = 1;
						break;
					}
				}
			}
		}
	}
	return memo[i][j][k]=res;
}

int main(){
	cin >> N;
	for(int i=0;i<N;++i){
		int cc;cin >> cc;
		c.push_back(cc);
	}
	memset(memo,0xff,sizeof(memo));
	cout << (dp(0,N,0) ? "yes" : "no") << endl;
	return 0;
}
accuracy: 0.6
time_ms: 20
memory_kb: 3500
final_rank: 15

code_snippet: #include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <cmath>
#include <iomanip>
#include <cassert>
#include <bitset>
using namespace std;

typedef pair<int, int> P;
#define rep(i, n) for (int i=0; i<(n); i++)
#define all(c) (c).begin(), (c).end()
#define uniq(c) c.erase(unique(all(c)), (c).end())
#define index(xs, x) (int)(lower_bound(all(xs), x) - xs.begin())
#define _1 first
#define _2 second
#define pb push_back
#define INF 1145141919
#define MOD 1000000007

int N;
int A[100];
bool dp[100][100][9][3];
signed main() {
  ios::sync_with_stdio(false); cin.tie(0);
  cin >> N;
  rep(i, N) cin >> A[i], A[i]--;
  rep(i, N) dp[i][i][A[i]][1] = 1;
  for (int len=2; len<=N; len++) {
    rep(l, N) {
      int r = l+len-1;
      if (r >= N) break;
      rep(j, 9) {
        rep(k, 3) {
          for (int t=l; t<=r-1; t++) {
            // [l, t] + [t+1, r]
            for (int s1=0; s1<=2; s1++) for (int s2=0; s2<=2; s2++) {
              dp[l][r][j][min(s1+s2, 2)] |= dp[l][t][j][s1] & dp[t+1][r][j][s2];
            }
          }
        }
        dp[l][r][j][0] |= dp[l][r][j][2];
      }
      bool ok = false;
      rep(j, 9) ok |= dp[l][r][j][0];
      rep(j, 9) dp[l][r][j][0] |= ok;
    }
  }

  bool b = 0;
  rep(i, 9) b |= dp[0][N-1][i][0];
  cout << (b?"yes":"no") << "\n";
  return 0;
}
accuracy: 1
time_ms: 60
memory_kb: 3436
final_rank: 9

code_snippet: #include <bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define REP(i,n) FOR(i,0,n)
#define ALL(v) (v).begin(),(v).end()
#define fi first
#define se second
template<typename A, typename B> inline bool chmax(A &a, B b) { if (a<b) { a=b; return 1; } return 0; }
template<typename A, typename B> inline bool chmin(A &a, B b) { if (a>b) { a=b; return 1; } return 0; }
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<pll, int> plp;
const ll INF = 1e9+100;
const ll MOD = 1e9+7;
const double EPS = 1e-10;
const bool debug = 0;
//--------------------------------//

int N;
int c[100];
bool dp[100][101][10];

int main() {
	cin >> N;
	REP(i, N) scanf("%d", c + i);
	
	REP(i, N - 1) if (c[i] == c[i + 1]) dp[i][i + 2][c[i]] = true;
	
	FOR(s, 2, N + 1) {
		REP(l, N - s + 1) {
			int r = l + s;
			
			REP(i, 10) REP(j, 10) {
				FOR(k, l + 1, r) {
					dp[l][r][0] |= dp[l][k][i] & dp[k][r][j]; // xx
					
					if (c[l] == c[r - 1]) {
						dp[l][r][c[l]] |= dp[l + 1][r - 1][i]; // 1x1
						if (c[l] == c[k]) dp[l][r][c[l]] |= dp[l + 1][k][i] & dp[k + 1][r - 1][j]; // 1x1x1
					}
				}
			}
			
			if (l > 0) dp[l - 1][r][c[l - 1]] |= dp[l][r][c[l - 1]];
			if (r < N) dp[l][r + 1][c[r]] |= dp[l][r][c[r]];
		}
	}
	
	bool ans = false;
	REP(i, 10) ans |= dp[0][N][i];
	puts(ans ? "yes" : "no");
	return 0;
}
accuracy: 1
time_ms: 40
memory_kb: 3252
final_rank: 6

code_snippet: #include <iostream>
#include <queue>
#include <vector>
using namespace std;

class S {
public:
	std::vector<int> p;
	S() {
	}
	bool clear(vector<int> p) {
		return p.empty();
	}
};

int main()
{
	int N;
	cin >> N;
	S now;
	int a = 0;
	for (int i = 0; i < N; i++) {
		cin >> a;
		now.p.push_back(a);
	}

	queue<S> que;
	que.push(now);

	while (!que.empty()) {
		now = que.front();
		que.pop();
		if (now.clear(now.p)) {
			cout << "yes" << endl;
			break;
		}
		int c = -1;
		for (int i = 0; i < now.p.size() - 1; i++) {
			if (c > -1) {
				if (now.p[i] == now.p[i + 1]) {
					if (i + 1 == now.p.size() - 1) {
						S nex;
						for (int i = 0; i < now.p.size(); i++) {
							nex.p.push_back(now.p[i]);
						}
						nex.p.erase(nex.p.begin() + c, nex.p.begin() + i + 2);
						que.push(nex);
						c = -1;
					}

					continue;

				}
				S nex;
				for (int i = 0; i < now.p.size(); i++) {
					nex.p.push_back(now.p[i]);
				}
				nex.p.erase(nex.p.begin() + c, nex.p.begin() + i + 1);
				que.push(nex);
				c = -1;
			}
			else if (now.p[i] == now.p[i + 1]) {
				c = i;

				if (c == now.p.size() - 2) {
					S nex;
					for (int i = 0; i < now.p.size(); i++) {
						nex.p.push_back(now.p[i]);
					}
					nex.p.erase(nex.p.begin() + c, nex.p.begin() + i + 2);
					que.push(nex);
					c = -1;
				}
			}
		}
	}
	if (!now.p.empty())
		cout << "no" << endl;
	return 0;
}
accuracy: 0.175
time_ms: 330
memory_kb: 50116
final_rank: 20

code_snippet: #include<complex>
#include<algorithm>
#include<iostream>
#include<iomanip>
#include<cmath>
#include<vector>
#include<map>
#include<sstream>
#include<ctime>
#include<cstdio>
#include<cstdlib>
#include<cassert>
#include<deque>
#include<queue>
#include<climits>
#include<set>
#include<list>
#include<cstring>
#include<stack>
#include<fstream>
#include<ctime>

#define REP(i,s,n) for(int i=s;i<n;i++)
#define rep(i,n) REP(i,0,n)

using namespace std;

int n,c[101];
bool dp[110][110];

int main(){
  cin >> n;
  rep(i,n) cin >> c[i];

  REP(len,1,n) {
    rep(sp,n) {
      if( sp + len >= n ) break;
      int L = sp, R = L + len; // [L,R]
      dp[L][R] = false;

      {
	set<int> S;
	REP(i,L,R+1) S.insert(c[i]);
	if( S.size() == 1 ) dp[L][R] = true;
      }
      if( dp[L][R] ) continue;
      REP(M,L+1,R) {
	if( dp[L][M] && dp[M+1][R] ) { dp[L][R] = true; break; }
      }
      if( dp[L][R] ) continue;
      REP(M1,L,R+1) REP(M2,M1,R+1) {
	if( dp[M1][M2] ) {
	  set<int> S;
	  int cnt = 0;
	  REP(i,L,R+1) if( !( M1 <= i && i <= M2 ) ) S.insert(c[i]), ++cnt;
	  if( cnt >= 2 && S.size() == 1 ) { dp[L][R] = true; goto Skip; }
	}
      }
    Skip:;
    }
  }
  puts(dp[0][n-1]?"yes":"no");
  return 0;
}
accuracy: 0.5375
time_ms: 680
memory_kb: 3124
final_rank: 18

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

int main() {
  int N;
  cin >> N;
  vector<int> c(N);
  for(auto& i: c) cin >> i;

  vector<vector<vector<bool>>> dp(N, vector<vector<bool>>(N, vector<bool>(10)));
  for(auto i = 0; i < N; ++i) dp[i][i][c[i]] = true;

  for(auto w = 1; w < N; ++w) for(auto i = 0; i < N - w; ++i) for(auto k = 0; k < 10; ++k) {
    auto j = i + w;
    for(auto x = i; x < j; ++x) {
      if(dp[i][x][0] && dp[x + 1][j][0]) dp[i][j][0] = true;
      if(dp[i][x][k] && dp[x + 1][j][k]) dp[i][j][0] = true;
      if(!k) continue;
      if(dp[i][x][0] && dp[x + 1][j][k]) dp[i][j][k] = true;
      if(dp[i][x][k] && dp[x + 1][j][0]) dp[i][j][k] = true;
      if(dp[i][x][k] && dp[x + 1][j][k]) dp[i][j][k] = true;
    }
  }

  cout << (dp[0][N-1][0] ? "yes" : "no") << endl;
}
accuracy: 1
time_ms: 10
memory_kb: 3796
final_rank: 2

code_snippet: #include <bits/stdc++.h>
using namespace std;
int n,num[101];
 

bool check(int l,int r){
  for(int i=l;i<=r;i++) if(num[l]!=num[i])return 0;
  return 1;
}

int used[101][101],mem[101][101]; 
int dfs(int l,int r){
  if(l==r)return 0;
  if(check(l,r))  return 1;
  if(used[l][r]++)return mem[l][r];
  
  int res=0;
  for(int i=l;num[l]==num[i];i++)
    for(int j=r;num[l]==num[j];j--){
      res|=dfs(l+1,r-1);
      for(int k=i+1;k<j;k++)
	res|=num[l]==num[k]&&dfs(i+1,k-1)&&dfs(k+1,j-1);
    }
   
  for(int i=l;i<r;i++) res|=dfs(l,i)&&dfs(i+1,r);
  return mem[l][r]=res;
}
 
int main(){
  cin>>n;
  for(int i=0;i<n;i++)cin>>num[i];
  cout<<(dfs(0,n-1)?"yes":"no")<<endl;;
  return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 3144
final_rank: 4

code_snippet: #include <bits/stdc++.h>
using namespace std;
int n,num[101];
 
int used[101][101],mem[101][101];
bool check(int l,int r){
  if(l==r) return 0;
  for(int i=l;i<=r;i++) if(num[l]!=num[i])return 0;
  return 1;
}
 
int dfs(int l,int r){
  if(l==r)return 0;
  if(check(l,r))  return 1;
  if(used[l][r]++)return mem[l][r];
   
  int res=0;
  for(int i=0;num[l]==num[l+i];i++)
    for(int j=0;num[l]==num[r-j];j++)
      res|=dfs(l+i+1,r-j-1);
  
  for(int i=l;num[l]==num[i];i++)
    for(int j=r;num[l]==num[j];j--)
      for(int k=i+1;k<j;k++)
	if(num[l]==num[k])res|=dfs(i+1,k-1)&&dfs(k+1,j-1);
  
   
  for(int i=l;i<r;i++) res|=dfs(l,i)&&dfs(i+1,r);
  return mem[l][r]=res;
}
 
int main(){
  cin>>n;
  for(int i=0;i<n;i++)cin>>num[i];
  cout<<(dfs(0,n-1)?"yes":"no")<<endl;;
  return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 3144
final_rank: 4