Problem:
Problem G:
エナジー・トランスポーター
とある研究所で，
    エネルギー伝達用の媒体の開発をしていた．
    この媒体は図3に示すような特殊な物質からなる
    ポリマー構造をなしている．
(-α-Ea-β-)
n
図3: エネルギー伝達用媒体の構造．
図の Ea で示した部分がこの媒体のもっとも特徴的な部位の
    エナジーアキュムレータ (Energy Accumulator) である．
    このEa基は 1 kJ 幅で離散化された多様なエネルギー状態を取ることができる．
    あるEa基を励起させると，
    そのEa基のα側に結合している隣接したEa基に蓄積されている全エネルギーを
    β側に結合している隣接したEa基に移動させるような効果を持つ
    発熱反応が引き起こされる（図4）．
    この反応の際，励起されるEa基のエネルギーが 1 kJ 消費される．
    なお，ポリマーの両端に位置するEa基やエネルギー状態が 0 kJ になっている
    Ea基に対しては励起反応は発生しないこと，
    およびEa基は十分に大きなエネルギーを蓄えることが可能であることが知られている．
図4: 中央のEa基を励起させたときの反応．
この性質を利用することでエネルギーの伝達を可能にしようと考えていたのだが，
    エネルギーを効率よく伝達するには各Ea基を励起させる順番が重要であることに
    研究者たちは気がついたのである．
幸い，励起させる順番や回数は任意に制御できるのだが，
    彼らには最適な励起手順がわからない．
    そこで彼らの発想の足がかりとして，
    初期状態のエネルギー分布に対して
    最右Ea基（β末端からもっとも近いEa基）
    に蓄えられうる最大のエネルギー量を計算してもらいたい．
Input
入力は複数のデータセットから構成され，
    以下のような形式で与えられる．
N
C
1
C
2
...
C
N
入力の先頭の整数
N
(0 <
N
≤ 60) が取り扱う問題のデータセット数であり，
    その後ろ 2
N
行に渡って，
    それぞれのデータセットごとの情報
C
k
が与えられる．
それぞれのデータセット
C
k
は以下のような形式で
    2行に渡り与えられる．
L
E
1
E
2
...
E
L
L
はそれぞれのデータセットで取り扱う媒体のEa鎖の長さであり，
    ここで与えられた数だけEa基が直列に結合していることを意味している．
    その次の行の
L
個の整数
E
k
は，
    長さ
L
のEa鎖のうちα末端を左端に据えたときに
    左から数えて
k
番目のEa鎖にはじめに蓄積されているエネルギー量を
    kJ単位で示したものである．
ここで， 0 ≤
E
k
≤ 4,
    1 ≤
L
≤ 80 であることが保証されている．
Output
出力は各データセットごとに，与えられた状況下での右端Ea鎖に到達可能な
    最大エネルギーをkJ単位で，整数値のみを1行で記述すること．
Sample Input
7
1
2
2
1 2
3
4 1 4
3
4 0 4
5
4 1 4 0 4
5
4 1 4 1 4
5
4 2 4 0 4
Output for the Sample Input
2
2
8
4
7
12
11

Submitted solutions:

code_snippet: #include <algorithm>
#include <iostream>
#include <vector>
#define REP(i, s, n) for (int i = s; i < n; i++)
#define rep(i, n) REP(i, 0, n)
#define MAX 150
using namespace std;
bool dp[MAX][MAX][2];
int main() {
  ios_base::sync_with_stdio(false); // to speed up I/O operations
  cin.tie(NULL); // untie cin and cout ties to speed up I/O operations
  int T;
  while (cin >> T) {
    while (T--) {
      int N;
      cin >> N;
      vector<int> input(N);
      rep(i, N) cin >> input[i];
      if (N <= 2) {
        cout << input[N - 1] << "\n";
        continue;
      }
      int ans = input[N - 1];
      REP(cur, 1, N - 1) {
        int curBit = cur & 1;
        dp[input[cur - 1]][input[cur]][curBit] = true;
        int R = input[cur + 1];
        rep(L, MAX) {
          rep(M, MAX) {
            if (!dp[L][M][curBit])
              continue;
            if (M == 0) {
              if (cur + 2 < N) {
                dp[M][R][(cur + 1) & 1] = true;
              } else
                ans = max(ans, R);
            } else {
              if (cur + 2 < N) {
                dp[M][R][(cur + 1) & 1] = true;
                dp[M - 1][R + L][(cur + 1) & 1] = true;
              } else {
                ans = max(ans, R + L);
              }
            }
          }
        }
        rep(i, MAX) rep(j, MAX) dp[i][j][curBit] = false;
      }
      cout << ans << "\n";
    }
  }
  return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 3496
final_rank: 15

code_snippet: #include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
#define MAX 150
using namespace std;

bool dp[2][MAX][MAX];

int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  
  int T;
  cin >> T;
  while (T--) {
    int N;
    cin >> N;
    int input[N];
    for(int i = 0; i < N; i++) cin >> input[i];
    
    if (N <= 2) {
      cout << input[N - 1] << endl;
      continue;
    }
    
    int ans = input[N - 1];
    fill(dp[0][0], dp[2][0], false);
    
    for(int cur = 1; cur < N - 1; cur++) {
        dp[cur & 1][input[cur - 1]][input[cur]] = true;
        int R = input[cur + 1];
        
        bool hasNext = (cur + 2 < N);
        
        for(int M = 0; M < MAX; M++) {
            for(int L = 0; L < MAX; L++) {
                if (!dp[cur & 1][L][M])
                    continue;
                if (M == 0) {
                    if (hasNext) {
                        dp[(cur + 1) & 1][M][R] = true;
                    } else
                        ans = max(ans, R);
                } else {
                    if (hasNext) {
                        dp[(cur + 1) & 1][M][R] = true;
                        dp[(cur + 1) & 1][M - 1][R + L] = true;
                    } else {
                        ans = max(ans, R + L);
                    }
                }
            }
        }
        for(int i = 0; i < MAX; i++) for(int j = 0; j < MAX; j++) dp[cur & 1][i][j] = false;
    }
    cout << ans << endl;
  }
  return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 3412
final_rank: 9

code_snippet: #include <iostream>
#include <vector>
#define REP(i, s, n) for (int i = s; i < n; i++)
#define rep(i, n) REP(i, 0, n)
#define MAX 150
using namespace std;
bool dp1[MAX][MAX];
bool dp2[MAX][MAX];
int main() {
  int T;
  while (cin >> T) {
    while (T--) {
      rep(i, MAX) rep(j, MAX) {
        dp1[i][j] = false;
        dp2[i][j] = false;
      }
      int N;
      cin >> N;
      int input[N];
      rep(i, N) cin >> input[i];
      if (N <= 2) {
        cout << input[N - 1] << endl;
        continue;
      }
      int ans = input[N - 1];
      REP(cur, 1, N - 1) {
        bool (*dp_curr)[MAX], (*dp_next)[MAX];
        if (cur & 1) {
          dp_curr = dp1;
          dp_next = dp2;
        } else {
          dp_curr = dp2;
          dp_next = dp1;
        }
        dp_curr[input[cur - 1]][input[cur]] = true;
        int R = input[cur + 1];
        rep(L, MAX) {
          rep(M, MAX) {
            if (!dp_curr[L][M])
              continue;
            if (M == 0) {
              if (cur + 2 < N) {
                dp_next[M][R] = true;
              } else
                ans = max(ans, R);
            } else {
              if (cur + 2 < N) {
                dp_next[M][R] = true;
                dp_next[M - 1][R + L] = true;
              } else {
                ans = max(ans, R + L);
              }
            }
          }
        }
        rep(i, MAX) rep(j, MAX) dp_curr[i][j] = false;
      }
      cout << ans << endl;
    }
  }
  return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 3384
final_rank: 4

code_snippet: #include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
#define REP(i, s, n) for (int i = s; i < n; i++)
#define rep(i, n) REP(i, 0, n)
#define inf (1 << 29)
#define MAX 150
using namespace std;
bool dp[MAX][MAX][2];
int main() {
  std::ios::sync_with_stdio(0);
  std::cin.tie(NULL);
  int T;
  while (cin >> T) {
    while (T--) {
      int N;
      cin >> N;
      int input[N];
      rep(i, N) cin >> input[i];
      if (N <= 2) {
        cout << input[N - 1] << "\n";
        continue;
      }
      int ans = input[N - 1];
      REP(cur, 1, N - 1) {
        int curPlusOneMod = (cur + 1) & 1;
        int curMod = cur & 1;
        dp[input[cur - 1]][input[cur]][curMod] = true;
        int R = input[cur + 1];
        rep(L, MAX) {
          rep(M, MAX) {
            if (!dp[L][M][curMod])
              continue;
            if (M == 0) {
              if (cur + 2 < N) {
                dp[M][R][curPlusOneMod] = true;
              } else
                ans = max(ans, R);
            } else {
              if (cur + 2 < N) {
                dp[M][R][curPlusOneMod] = true;
                dp[M - 1][R + L][curPlusOneMod] = true;
              } else {
                ans = max(ans, R + L);
              }
            }
          }
        }
        rep(i, MAX) rep(j, MAX) dp[i][j][curMod] = false;
      }
      cout << ans << "\n";
    }
  }
  return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 3416
final_rank: 10

code_snippet: #include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>

using namespace std;

const int MAX = 150;

int main() {
  int T;
  while (cin >> T) {
    while (T--) {
      int N;
      cin >> N;
      vector<int> input(N);
      for (int i = 0; i < N; i++) {
        cin >> input[i];
      }
      if (N <= 2) {
        cout << input[N - 1] << endl;
        continue;
      }
      int ans = input[N - 1];
      bool dp[MAX][MAX][2] = {false};
      int curAnd1;
      bool curPlus2LessThanN;
      for (int cur = 1; cur < N - 1; cur++) {
        curAnd1 = cur & 1;
        curPlus2LessThanN = cur + 2 < N;
        dp[input[cur - 1]][input[cur]][curAnd1] = true;
        int R = input[cur + 1];
        for (int L = 0; L < MAX; L++) {
          for (int M = 0; M < MAX; M++) {
            if (!dp[L][M][curAnd1])
              continue;
            if (M == 0) {
              if (curPlus2LessThanN) {
                dp[M][R][curAnd1 ^ 1] = true;
              } else {
                ans = max(ans, R);
              }
            } else {
              if (curPlus2LessThanN) {
                dp[M][R][curAnd1 ^ 1] = true;
                dp[M - 1][R + L][curAnd1 ^ 1] = true;
              } else {
                ans = max(ans, R + L);
              }
            }
          }
        }
        for (int i = 0; i < MAX; i++) {
          for (int j = 0; j < MAX; j++) {
            dp[i][j][curAnd1] = false;
          }
        }
      }
      cout << ans << endl;
    }
  }
  return 0;
}
accuracy: 1
time_ms: 40
memory_kb: 3240
final_rank: 6

code_snippet: #include <algorithm>
#include <iostream>
#include <vector>
#define MAX 150
#define rep(i, n) for (int i = 0; i < n; ++i)
using namespace std;

int dp[MAX][MAX][2];

int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);

  int T;
  cin >> T;

  while (T--) {
    rep(i, MAX) rep(j, MAX) rep(l, 2) dp[i][j][l] = false;

    int N;
    cin >> N;

    vector<int> input(N);

    for (auto& in : input) cin >> in;

    if (N <= 2) {
        cout << input[N - 1] << '\n';
        continue;
    }

    int ans = input[N - 1];

    for (int cur = 1; cur < N - 1; ++cur) {
        dp[input[cur - 1]][input[cur]][cur & 1] = true;
        int R = input[cur + 1];

        rep(L, MAX) {
          rep(M, MAX) {
            if (!dp[L][M][cur & 1])
              continue;

            if (cur + 2 < N) {
              dp[M][R][(cur + 1) & 1] = true;

              if (M > 0) 
                dp[M - 1][R + L][(cur + 1) & 1] = true;
            } else {
              ans = max(ans, M > 0 ? R + L : R);
            }
          }
        }

        rep(i, MAX) rep(j, MAX) dp[i][j][cur & 1] = false;
      }

      cout << ans << '\n';
    }

  return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 3524
final_rank: 16

code_snippet: #include <algorithm>
#include <iostream>
#include <vector>
#define MAX 150

using namespace std;

bool dp[MAX][MAX][2];

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    int T;
    cin >> T;
    while (T--) {
        for(int i = 0; i < MAX; ++i)
            for(int j = 0; j < MAX; ++j)
                dp[i][j][0] = dp[i][j][1] = false;

        int N;
        cin >> N;
        vector<int> input(N);
        for(int i = 0; i < N; ++i)
            cin >> input[i];

        if (N <= 2) {
            cout << input[N - 1] << "\n";
            continue;
        }
        int ans = input[N - 1];
        for(int cur = 1; cur < N - 1; ++cur) {
            dp[input[cur - 1]][input[cur]][cur & 1] = true;
            int R = input[cur + 1];
            for(int L = 0; L < MAX; ++L) {
                for(int M = 0; M < MAX; ++M) {
                    if (!dp[L][M][cur & 1])
                        continue;
                    if (M == 0) {
                        if (cur + 2 < N)
                            dp[M][R][(cur + 1) & 1] = true;
                        else
                            ans = max(ans, R);
                    } else {
                        if (cur + 2 < N) {
                            dp[M][R][(cur + 1) & 1] = true;
                            dp[M - 1][R + L][(cur + 1) & 1] = true;
                        } else {
                            ans = max(ans, R + L);
                        }
                    }
                }
            }
            for(int i = 0; i < MAX; ++i)
                for(int j = 0; j < MAX; ++j)
                    dp[i][j][cur & 1] = false;
        }
        cout << ans << "\n";
    }
    return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 3420
final_rank: 11

code_snippet: #include <algorithm>
#include <iostream>
#include <vector>
#define MAX 150
using namespace std;
bool dp[MAX][MAX][2];
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  int T;
  cin >> T;
  while (T--) {
    for(int i = 0; i < MAX; ++i) 
      for(int j = 0; j < MAX; ++j)
        dp[i][j][0] = dp[i][j][1] = false;
    int N;
    cin >> N;
    vector<int> input(N);
    for(int i = 0; i < N; ++i) cin >> input[i];
    if (N <= 2) {
        cout << input[N - 1] << '\n';
        continue;
    }
    int ans = input[N - 1];
    for(int cur = 1; cur < N - 1; ++cur) {
        dp[input[cur - 1]][input[cur]][cur & 1] = true;
        int R = input[cur + 1];
        for(int L = 0; L < MAX; ++L) {
          for(int M = 0; M < MAX; ++M) {
            if (!dp[L][M][cur & 1]) continue;
            if (!M) {
              if (cur + 2 < N) {
                dp[M][R][(cur + 1) & 1] = true;
              } else
                ans = max(ans, R);
            } else {
              if (cur + 2 < N) {
                dp[M][R][(cur + 1) & 1] = true;
                dp[M - 1][R + L][(cur + 1) & 1] = true;
              } else {
                ans = max(ans, R + L);
              }
            }
          }
        }
        for(int i = 0; i < MAX; ++i) 
          for(int j = 0; j < MAX; ++j)
            dp[i][j][cur & 1] = false;
    }
    cout << ans << '\n';
  }
  return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 3408
final_rank: 8

code_snippet: #include <algorithm>
#include <iostream>
#include <vector>
#define REP(i, s, n) for (int i = s; i < n; i++)
#define MAX 150
using namespace std;
bool dp[MAX][MAX][2];
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  
  int T;
  cin >> T;
  while (T--) {
    REP(i, 0, MAX) REP(j, 0, MAX) REP(l, 0, 2) dp[i][j][l] = false;
    int N;
    cin >> N;
    vector<int> input(N);
    REP(i, 0, N) cin >> input[i];
    if (N <= 2) {
        cout << input[N - 1] << '\n';
        continue;
    }
    int ans = input[N - 1];
    REP(cur, 1, N - 1) {
      dp[input[cur - 1]][input[cur]][cur & 1] = true;
      int R = input[cur + 1];
      REP(L, 0, MAX) {
        REP(M, 0, MAX) {
          if (!dp[L][M][cur & 1])
            continue;
          if (M == 0) {
            if (cur + 2 < N) {
              dp[M][R][(cur + 1) & 1] = true;
            } else
              ans = max(ans, R);
          } else {
            if (cur + 2 < N) {
              dp[M][R][(cur + 1) & 1] = true;
              dp[M - 1][R + L][(cur + 1) & 1] = true;
            } else {
              ans = max(ans, R + L);
            }
          }
        }
      }
      REP(i, 0, MAX) REP(j, 0, MAX) dp[i][j][cur & 1] = false;
    }
    cout << ans << '\n';
  }
  return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 3420
final_rank: 11

code_snippet: #include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
#define REP(i, s, n) for (int i = s; i < n; i++)
#define rep(i, n) REP(i, 0, n)
#define inf (1 << 29)
#define MAX 130
using namespace std;
bool dp[MAX][MAX][2];
int main() {
  int T;
  while (cin >> T) {
    while (T--) {
      rep(i, MAX) rep(j, MAX) rep(l, 2) dp[i][j][l] = false;
      int N;
      cin >> N;
      int input[N];
      rep(i, N) cin >> input[i];
      if (N <= 2) {
        cout << input[N - 1] << endl;
        continue;
      }
      int ans = input[N - 1];
      REP(cur, 1, N - 1) {
        dp[input[cur - 1]][input[cur]][cur & 1] = true;
        int R = input[cur + 1];
        rep(L, MAX) {
          rep(M, MAX) {
            if (!dp[L][M][cur & 1])
              continue;
            if (M == 0) {
              if (cur + 2 < N) {
                dp[M][R][(cur + 1) & 1] = true;
              } else
                ans = max(ans, R);
            } else {
              if (cur + 2 < N) {
                dp[M][R][(cur + 1) & 1] = true;
                dp[M - 1][R + L][(cur + 1) & 1] = true;
              } else {
                ans = max(ans, R + L);
              }
            }
          }
        }
        rep(i, MAX) rep(j, MAX) dp[i][j][cur & 1] = false;
      }
      cout << ans << endl;
    }
  }
  return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 3084
final_rank: 1

code_snippet: #include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
#define REP(i, s, n) for (int i = s; i < n; i++)
#define rep(i, n) REP(i, 0, n)
#define inf (1 << 29)
#define MAX 150
using namespace std;
bool dp[MAX][MAX][2];
int main() {
  int T;
  while (cin >> T) {
    while (T--) {
      rep(i, MAX) rep(j, MAX) rep(l, 2) dp[i][j][l] = false;
      int N;
      cin >> N;
      int input[N];
      rep(i, N) cin >> input[i];
      if (N <= 2) {
        cout << input[N - 1] << endl;
        continue;
      }
      int ans = input[N - 1];
      REP(cur, 1, N - 1) {
        dp[input[cur - 1]][input[cur]][cur & 1] = true;
        int R = input[cur + 1];
        rep(L, MAX) {
          rep(M, MAX) {
            if (!dp[L][M][cur & 1])
              continue;
            if (M == 0) {
              if (cur + 2 < N) {
                dp[M][R][(cur + 1) & 1] = true;
              } else
                ans = max(ans, R);
            } else {
              if (cur + 2 < N) {
                dp[M][R][(cur + 1) & 1] = true;
                dp[M - 1][R + L][(cur + 1) & 1] = true;
              } else {
                ans = max(ans, R + L);
              }
            }
          }
        }
        rep(i, MAX) rep(j, MAX) dp[i][j][cur & 1] = false;
      }
      cout << ans << endl;
    }
  }
  return 0;
}
accuracy: 1
time_ms: 40
memory_kb: 3368
final_rank: 13

code_snippet: #include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
#define REP(i, s, n) for (int i = s; i < n; i++)
#define rep(i, n) REP(i, 0, n)
#define inf (1 << 29)
#define MAX 150
using namespace std;
bool dp[2][MAX][MAX];
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  int T;
  cin >> T;
  while (T--) {
    rep(i, MAX) rep(j, MAX) dp[0][i][j] = dp[1][i][j] = false;
    int N;
    cin >> N;
    int input[N];
    rep(i, N) cin >> input[i];
    if (N <= 2) {
      cout << input[N - 1] << endl;
      continue;
    }
    int ans = input[N - 1];
    int cur = 0;
    REP(i, 0, N - 2) {
      rep(j, MAX) rep(k, MAX) dp[cur ^ 1][j][k] = false;
      dp[cur][input[i]][input[i + 1]] = true;
      int R = input[i + 2];
      rep(L, MAX) {
        rep(M, MAX) {
          if (!dp[cur][L][M])
            continue;
          if (M == 0) {
            if (i + 3 < N) {
              dp[cur ^ 1][M][R] = true;
            } else
              ans = max(ans, R);
          } else {
            if (i + 3 < N) {
              dp[cur ^ 1][M][R] = true;
              dp[cur ^ 1][M - 1][R + L] = true;
            } else {
              ans = max(ans, R + L);
            }
          }
        }
      }
      cur ^= 1;
    }
    cout << ans << endl;
  }
  return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 3296
final_rank: 4

code_snippet: #include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
#define REP(i, s, n) for (int i = s; i < n; i++)
#define rep(i, n) REP(i, 0, n)
#define inf (1 << 29)
#define MAX 150
using namespace std;
bool dp[2][MAX][MAX];
int main() {
  int T;
  while (cin >> T) {
    while (T--) {
      rep(i, MAX) rep(j, MAX) dp[0][i][j] = false;
      int N;
      cin >> N;
      int input[N];
      rep(i, N) cin >> input[i];
      if (N <= 2) {
        cout << input[N - 1] << endl;
        continue;
      }
      int ans = input[N - 1];
      int cur = 1;
      dp[0][input[cur - 1]][input[cur]] = true;
      int R = input[cur + 1];
      rep(L, MAX) {
        rep(M, MAX) {
          if (!dp[0][L][M])
            continue;
          if (M == 0) {
            if (cur + 2 < N) {
              dp[1][M][R] = true;
            } else
              ans = max(ans, R);
          } else {
            if (cur + 2 < N) {
              dp[1][M][R] = true;
              dp[1][M - 1][R + L] = true;
            } else {
              ans = max(ans, R + L);
            }
          }
        }
      }
      cur++;
      rep(i, MAX) rep(j, MAX) dp[0][i][j] = false;
      while (cur < N - 1) {
        R = input[cur + 1];
        rep(L, MAX) {
          rep(M, MAX) {
            if (!dp[1][L][M])
              continue;
            if (M == 0) {
              if (cur + 2 < N) {
                dp[0][M][R] = true;
              } else
                ans = max(ans, R);
            } else {
              if (cur + 2 < N) {
                dp[0][M][R] = true;
                dp[0][M - 1][R + L] = true;
              } else {
                ans = max(ans, R + L);
              }
            }
          }
        }
        cur++;
        rep(i, MAX) rep(j, MAX) dp[1][i][j] = false;
        swap(dp[0], dp[1]);
      }
      cout << ans << endl;
    }
  }
  return 0;
}
accuracy: 1
time_ms: 60
memory_kb: 3212
final_rank: 14

code_snippet: #include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
#define REP(i, s, n) for (int i = s; i < n; i++)
#define rep(i, n) REP(i, 0, n)
#define inf (1 << 29)
#define MAX 200
using namespace std;
bool dp[MAX][MAX][2];
int main() {
  int T;
  while (cin >> T) {
    while (T--) {
      rep(i, MAX) rep(j, MAX) rep(l, 2) dp[i][j][l] = false;
      int N;
      cin >> N;
      int input[N];
      rep(i, N) scanf("%d", &input[i]);
      if (N <= 2) {
        cout << input[N - 1] << endl;
        continue;
      }
      int ans = input[N - 1];
      REP(cur, 1, N - 1) {
        dp[input[cur - 1]][input[cur]][cur & 1] = true;
        int R = input[cur + 1];
        rep(L, MAX) {
          rep(M, MAX) {
            if (!dp[L][M][cur & 1])
              continue;
            if (M == 0) {
              if (cur + 2 < N) {
                dp[M][R][(cur + 1) & 1] = true;
              } else
                ans = max(ans, R);
            } else {
              if (cur + 2 < N) {
                dp[M][R][(cur + 1) & 1] = true;
                dp[M - 1][R + L][(cur + 1) & 1] = true;
              } else {
                ans = max(ans, R + L);
              }
            }
          }
        }
        rep(i, MAX) rep(j, MAX) dp[i][j][cur & 1] = false;
      }
      cout << ans << endl;
    }
  }
  return 0;
}
accuracy: 1
time_ms: 60
memory_kb: 3424
final_rank: 17

code_snippet: #include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
#define REP(i, s, n) for (int i = s; i < n; i++)
#define rep(i, n) REP(i, 0, n)
#define inf (1 << 29)
#define MAX 100
using namespace std;
bool dp[MAX][MAX][2];
int main() {
  int T;
  while (cin >> T) {
    while (T--) {
      rep(i, MAX) rep(j, MAX) rep(l, 2) dp[i][j][l] = false;
      int N;
      cin >> N;
      int input[N];
      rep(i, N) cin >> input[i];
      if (N <= 2) {
        cout << input[N - 1] << endl;
        continue;
      }
      int ans = input[N - 1];
      REP(cur, 1, N - 1) {
        dp[input[cur - 1]][input[cur]][cur & 1] = true;
        int R = input[cur + 1];
        rep(L, MAX) {
          rep(M, MAX) {
            if (!dp[L][M][cur & 1])
              continue;
            if (M == 0) {
              if (cur + 2 < N) {
                dp[M][R][(cur + 1) & 1] = true;
              } else
                ans = max(ans, R);
            } else {
              if (cur + 2 < N) {
                dp[M][R][(cur + 1) & 1] = true;
                dp[M - 1][R + L][(cur + 1) & 1] = true;
              } else {
                ans = max(ans, R + L);
              }
            }
          }
        }
        rep(i, MAX) rep(j, MAX) dp[i][j][cur & 1] = false;
      }
      cout << ans << endl;
    }
  }
  return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3372
final_rank: 3

code_snippet: #include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
#define REP(i, s, n) for (int i = s; i < n; i++)
#define rep(i, n) REP(i, 0, n)
#define inf (1 << 29)
#define MAX 100
using namespace std;
bool dp[MAX][MAX][2];
int main() {
  int T;
  while (cin >> T) {
    while (T--) {
      rep(i, MAX) rep(j, MAX) rep(l, 2) dp[i][j][l] = false;
      int N;
      cin >> N;
      int input[N];
      rep(i, N) scanf("%d", &input[i]);
      if (N <= 2) {
        cout << input[N - 1] << endl;
        continue;
      }
      int ans = input[N - 1];
      REP(cur, 1, N - 1) {
        dp[input[cur - 1]][input[cur]][cur & 1] = true;
        int R = input[cur + 1];
        rep(L, MAX) {
          rep(M, MAX) {
            if (!dp[L][M][cur & 1])
              continue;
            if (M == 0) {
              if (cur + 2 < N) {
                dp[M][R][(cur + 1) & 1] = true;
              } else
                ans = max(ans, R);
            } else {
              if (cur + 2 < N) {
                dp[M][R][(cur + 1) & 1] = true;
                dp[M - 1][R + L][(cur + 1) & 1] = true;
              } else {
                ans = max(ans, R + L);
              }
            }
          }
        }
        rep(i, MAX) rep(j, MAX) dp[i][j][cur & 1] = false;
      }
      cout << ans << endl;
    }
  }
  return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3268
final_rank: 2

code_snippet: #include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
#define REP(i, s, n) for (int i = s; i < n; i++)
#define rep(i, n) REP(i, 0, n)
#define inf (1 << 29)
#define MAX 150
using namespace std;
bool dp[MAX][MAX][2];
int main() {
  int T;
  while (cin >> T) {
    while (T--) {
      rep(i, MAX) rep(j, MAX) rep(l, 2) dp[i][j][l] = false;
      int N;
      cin >> N;
      int input[N];
      rep(i, N) cin >> input[i];
      int ans = input[N - 1];
      REP(cur, 1, N - 1) {
        dp[input[cur - 1]][input[cur]][cur & 1] = true;
        int R = input[cur + 1];
        rep(L, MAX) {
          rep(M, MAX) {
            if (!dp[L][M][cur & 1])
              continue;
            if (M == 0) {
              if (cur + 2 < N) {
                dp[M][R][(cur + 1) & 1] = true;
              } else
                ans = max(ans, R);
            } else {
              if (cur + 2 < N) {
                dp[M][R][(cur + 1) & 1] = true;
                dp[M - 1][R + L][(cur + 1) & 1] = true;
              } else {
                ans = max(ans, R + L);
              }
            }
          }
        }
        rep(i, MAX) rep(j, MAX) dp[i][j][cur & 1] = false;
      }
      cout << ans << endl;
    }
  }
  return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 3372
final_rank: 7