problem_id stringlengths 6 6 | buggy_code stringlengths 8 526k ⌀ | fixed_code stringlengths 12 526k ⌀ | labels listlengths 0 15 ⌀ | buggy_submission_id int64 1 1.54M ⌀ | fixed_submission_id int64 2 1.54M ⌀ | user_id stringlengths 10 10 ⌀ | language stringclasses 9
values |
|---|---|---|---|---|---|---|---|
p03162 | #include <bits/stdc++.h>
using namespace std;
int n, a[100007], b[100007], c[100007], dp[100007][3], k;
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i] >> c[i];
}
for (int i = 1; i <= n; i++) {
dp[i][0] = max(dp[i - 1][1], dp[i - 1][2]) + a[i];
dp[i][1] = max(dp[i - 1][0], dp[i - 1][2]) + b[i];
dp[i][2] = max(dp[i - 1][1], dp[i - 1][0]) + c[i];
}
int mx;
for (int i = 0; i < 3; i++)
mx = max(mx, dp[n][i]);
cout << mx;
} | #include <bits/stdc++.h>
using namespace std;
int n, a[100007], b[100007], c[100007], dp[100007][3], k;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i] >> c[i];
}
for (int i = 1; i <= n; i++) {
dp[i][0] = max(dp[i - 1][1], dp[i - 1][2]) + a[i];
dp[i][1] = max(dp[i - 1][0], dp[i - 1][2]) + b[i];
dp[i][2] = max(dp[i - 1][1], dp[i - 1][0]) + c[i];
}
int mx;
for (int i = 0; i < 3; i++)
mx = max(mx, dp[n][i]);
cout << mx;
} | [
"expression.operation.binary.remove"
] | 962,702 | 962,703 | u666935035 | cpp |
p03162 | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
new_data_set;
#define int long long
#define fast \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define localin \
freopen("C:\\Users\\hp\\Desktop\\CPP\\inout\\inputf.in", "r", stdin);
#define localout \
freopen("C:\\Users\\hp\\Desktop\\CPP\\inout\\outputf.in", "w", stdout);
const int MAX = 2e5 + 5;
#define ld long double
#define endl "\n"
#define pb push_back
#define ff first
#define ss second
#define vi vector<int>
#define tot(v) v.begin(), v.end()
#define rtcheck \
cout << "saurabh\n"; \
exit(0);
#define vcheck(x) cout << #x << " " << x << endl;
#define pint pair<int, int>
#define forn for (int i = 0; i < n; i++)
const int modu = 1e9 + 7;
const int inf = 1e17;
struct activity {
int A, B, C;
};
int solve(vector<activity> ar, int n) {
int dp[n][3];
dp[0][0] = ar[0].A;
dp[0][1] = ar[0].B;
dp[0][2] = ar[0].C;
for (int i = 1; i < n; i++) {
dp[i][0] = ar[i].A + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = ar[i].B + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = ar[i].C + max(dp[i - 1][1], dp[i - 1][0]);
}
int res = max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2]));
return res;
}
int32_t main() {
fast;
int t;
t = 1;
// cin>>t;
while (t--) {
int n;
cin >> n;
vector<activity> ar;
for (int i = 0; i < n; i++) {
cin >> ar[i].A;
cin >> ar[i].B;
cin >> ar[i].C;
}
int ans = solve(ar, n);
cout << ans << endl;
}
}
| #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
new_data_set;
#define int long long
#define fast \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define localin \
freopen("C:\\Users\\hp\\Desktop\\CPP\\inout\\inputf.in", "r", stdin);
#define localout \
freopen("C:\\Users\\hp\\Desktop\\CPP\\inout\\outputf.in", "w", stdout);
const int MAX = 2e5 + 5;
#define ld long double
#define endl "\n"
#define pb push_back
#define ff first
#define ss second
#define vi vector<int>
#define tot(v) v.begin(), v.end()
#define rtcheck \
cout << "saurabh\n"; \
exit(0);
#define vcheck(x) cout << #x << " " << x << endl;
#define pint pair<int, int>
#define forn for (int i = 0; i < n; i++)
const int modu = 1e9 + 7;
const int inf = 1e17;
struct activity {
int A, B, C;
};
int solve(vector<activity> ar, int n) {
int dp[n][3];
dp[0][0] = ar[0].A;
dp[0][1] = ar[0].B;
dp[0][2] = ar[0].C;
for (int i = 1; i < n; i++) {
dp[i][0] = ar[i].A + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = ar[i].B + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = ar[i].C + max(dp[i - 1][1], dp[i - 1][0]);
}
int res = max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2]));
return res;
}
int32_t main() {
fast;
int t;
t = 1;
// cin>>t;
while (t--) {
int n;
cin >> n;
vector<activity> ar(n + 1);
for (int i = 0; i < n; i++) {
cin >> ar[i].A;
cin >> ar[i].B;
cin >> ar[i].C;
}
int ans = solve(ar, n);
cout << ans << endl;
}
}
| [
"call.arguments.add"
] | 962,707 | 962,708 | u390430783 | cpp |
p03162 | #pragma region header
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <math.h>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
// ===============================================================
// using系
#pragma region header
using namespace std;
using ll = long long;
using vl = vector<long long>;
using vvl = vector<vector<long long>>;
using vvi = vector<vector<int>>;
using Graph = vvi;
using vs = vector<string>;
using vc = vector<char>;
using vcc = vector<vector<char>>;
using vm = vector<short>;
using vmm = vector<vector<short>>;
using pii = pair<int, int>;
using psi = pair<string, int>;
using ld = long double;
using ull = unsigned long long;
using ui = unsigned int;
using qul = queue<ll>;
using pql = priority_queue<ll>;
using kaage = priority_queue<int, vector<int>, greater<int>>;
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
constexpr ll mod = 1e9 + 7;
#pragma endregion
// ========================================================================
// define系
//#define int long long
#define rep(i, n) for (ll i = 0; i < n; i++)
#define REP(i, n) for (ll i = 1; i <= n; i++)
// ========================================================================
//ライブラリ
#pragma region header
ll gcd(ll a, ll b) {
if (a % b == 0) {
return (b);
} else {
return (gcd(b, a % b));
}
}
//最大公約数
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
//最小公倍数
ll box(double a) {
ll b = a;
return b;
}
//切り捨て
ll fff(double a) {
ll b = a + 0.5;
return b;
}
//四捨五入
ll mch(ll n) {
if (n == 1)
return 1;
else
return n * mch(n - 1);
}
// 1から整数nまでの階乗を出す(INFで割っていない)
bool prime(ll a) //素数判定、primeならtrue,違うならfalse
{
if (a < 2)
return false;
else if (a == 2)
return true;
else if (a % 2 == 0)
return false;
double m = sqrt(a);
for (int i = 3; i <= m; i += 2) {
if (a % i == 0) {
return false;
}
}
// 素数である
return true;
}
//素数判定
ll modpow(ll a, ll n, ll mod) {
ll hi = 1;
while (n > 0) {
if (n & 1)
hi = hi * a % mod;
a = a * a % mod;
n >>= 1;
}
return hi;
}
//いろいろやります（ただの前座）
ll mg(ll a, ll mod) { return modpow(a, mod - 2, mod); }
//割り算の10^9+7等対策で逆元を出します
ll num(ll a) {
string s = to_string(a);
ll sum = 0;
for (int j = 0; j < s.size(); ++j) {
sum += s[j] - '0';
}
return sum;
}
//整数aのすべての桁の和
#pragma endregion
#pragma endregion
// ========================================================================
#pragma region header
//ある程度のテンプレ(いじって使う)
//これとBFS、あとその時その時で使うものはここに書く
vector<bool> seens;
void dfs(const Graph &G, int v) {
seens[v] = true; // v を訪問済にする
// v から行ける各頂点 next_v について
for (auto next_v : G[v]) {
if (seens[next_v])
continue; // next_v が探索済だったらスルー
dfs(G, next_v); // 再帰的に探索
}
}
// ========================================================================
#pragma endregion
/*signed*/ int main() {
ll n;
cin >> n;
ll dp[100005][3];
ll a, b, c;
cin >> a >> b >> c;
dp[0][0] = a;
dp[0][1] = b;
dp[0][2] = c;
for (int i = 1; i < n; i++) {
ll a, b, c;
cin >> a >> b >> c;
dp[i][0] = max(dp[i - 1][1] + a, dp[i - 1][2] + a);
dp[i][1] = max(dp[i - 1][0] + b, dp[i - 1][2] + b);
dp[i][2] = max(dp[i - 1][1] + c, dp[i - 1][2] + c);
}
cout << max({dp[n - 1][0], dp[n - 1][1], dp[n - 1][2]}) << endl;
return 0;
} | #pragma region header
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <math.h>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
// ===============================================================
// using系
#pragma region header
using namespace std;
using ll = long long;
using vl = vector<long long>;
using vvl = vector<vector<long long>>;
using vvi = vector<vector<int>>;
using Graph = vvi;
using vs = vector<string>;
using vc = vector<char>;
using vcc = vector<vector<char>>;
using vm = vector<short>;
using vmm = vector<vector<short>>;
using pii = pair<int, int>;
using psi = pair<string, int>;
using ld = long double;
using ull = unsigned long long;
using ui = unsigned int;
using qul = queue<ll>;
using pql = priority_queue<ll>;
using kaage = priority_queue<int, vector<int>, greater<int>>;
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
constexpr ll mod = 1e9 + 7;
#pragma endregion
// ========================================================================
// define系
//#define int long long
#define rep(i, n) for (ll i = 0; i < n; i++)
#define REP(i, n) for (ll i = 1; i <= n; i++)
// ========================================================================
//ライブラリ
#pragma region header
ll gcd(ll a, ll b) {
if (a % b == 0) {
return (b);
} else {
return (gcd(b, a % b));
}
}
//最大公約数
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
//最小公倍数
ll box(double a) {
ll b = a;
return b;
}
//切り捨て
ll fff(double a) {
ll b = a + 0.5;
return b;
}
//四捨五入
ll mch(ll n) {
if (n == 1)
return 1;
else
return n * mch(n - 1);
}
// 1から整数nまでの階乗を出す(INFで割っていない)
bool prime(ll a) //素数判定、primeならtrue,違うならfalse
{
if (a < 2)
return false;
else if (a == 2)
return true;
else if (a % 2 == 0)
return false;
double m = sqrt(a);
for (int i = 3; i <= m; i += 2) {
if (a % i == 0) {
return false;
}
}
// 素数である
return true;
}
//素数判定
ll modpow(ll a, ll n, ll mod) {
ll hi = 1;
while (n > 0) {
if (n & 1)
hi = hi * a % mod;
a = a * a % mod;
n >>= 1;
}
return hi;
}
//いろいろやります（ただの前座）
ll mg(ll a, ll mod) { return modpow(a, mod - 2, mod); }
//割り算の10^9+7等対策で逆元を出します
ll num(ll a) {
string s = to_string(a);
ll sum = 0;
for (int j = 0; j < s.size(); ++j) {
sum += s[j] - '0';
}
return sum;
}
//整数aのすべての桁の和
#pragma endregion
#pragma endregion
// ========================================================================
#pragma region header
//ある程度のテンプレ(いじって使う)
//これとBFS、あとその時その時で使うものはここに書く
vector<bool> seens;
void dfs(const Graph &G, int v) {
seens[v] = true; // v を訪問済にする
// v から行ける各頂点 next_v について
for (auto next_v : G[v]) {
if (seens[next_v])
continue; // next_v が探索済だったらスルー
dfs(G, next_v); // 再帰的に探索
}
}
// ========================================================================
#pragma endregion
/*signed*/ int main() {
ll n;
cin >> n;
ll dp[100005][3];
ll a, b, c;
cin >> a >> b >> c;
dp[0][0] = a;
dp[0][1] = b;
dp[0][2] = c;
for (int i = 1; i < n; i++) {
ll a, b, c;
cin >> a >> b >> c;
dp[i][0] = max(dp[i - 1][1] + a, dp[i - 1][2] + a);
dp[i][1] = max(dp[i - 1][0] + b, dp[i - 1][2] + b);
dp[i][2] = max(dp[i - 1][0] + c, dp[i - 1][1] + c);
}
cout << max({dp[n - 1][0], dp[n - 1][1], dp[n - 1][2]}) << endl;
return 0;
} | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 962,709 | 962,710 | u926006934 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 5;
int main() {
int n, k;
cin >> n;
vector<int> dp(3, 0);
for (int i = 0; i < n; i++) {
vector<int> dpn(3, INF);
vector<int> p(3);
for (int j = 0; j < 3; j++)
cin >> p[j];
// for(int j=0; j<3; ++j) cout<<p[j]<<" ";
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
if (j != k)
dpn[k] = min(dpn[k], dp[j] + p[k]);
}
}
dp = dpn;
// for(int j=0; j<3; ++j) cout<<dp[j]<<" ";
// cout<<"\n";
}
cout << max(dp[0], max(dp[1], dp[2])) << "\n";
} | #include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 5;
int main() {
int n, k;
cin >> n;
vector<int> dp(3, 0);
for (int i = 0; i < n; i++) {
vector<int> dpn(3, -1);
vector<int> p(3);
for (int j = 0; j < 3; j++)
cin >> p[j];
// for(int j=0; j<3; ++j) cout<<p[j]<<" ";
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
if (j != k)
dpn[k] = max(dpn[k], dp[j] + p[k]);
}
}
dp = dpn;
// for(int j=0; j<3; ++j) cout<<dp[j]<<" ";
// cout<<"\n";
}
cout << max(dp[0], max(dp[1], dp[2])) << "\n";
} | [
"identifier.replace.remove",
"literal.replace.add",
"call.arguments.change",
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 962,713 | 962,714 | u001462978 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int dp[110000][3];
int main() {
int n;
cin >> n;
int a[n], b[n], c[n];
for (int i = 0; i < n; i++)
cin >> a[i] >> b[i] >> c[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
if (i == 0) {
if (j == 0)
dp[i % 2][j] = a[i];
else if (j == 1)
dp[i % 2][j] = b[i];
else if (j == 2)
dp[i % 2][j] = c[i];
} else {
for (int k = 0; k < 3; k++) {
if (j == k)
continue;
if (j == 0)
dp[i % 2][j] = max(dp[i % 2][j], dp[(i - 1) % 2][k] + a[i]);
else if (j == 1)
dp[i % 2][j] = max(dp[i % 2][j], dp[(i - 1) % 2][k] + b[i]);
else if (j == 2)
dp[i % 2][j] = max(dp[i % 2][j], dp[(i - 1) % 2][k] + c[i]);
}
}
}
}
int ret = 0;
ret = max(dp[(n - 1) % 2][0], dp[n - 1][1]);
ret = max(ret, dp[(n - 1) % 2][2]);
cout << ret;
}
| #include <bits/stdc++.h>
using namespace std;
int dp[2][3];
int main() {
int n;
cin >> n;
int a[n], b[n], c[n];
for (int i = 0; i < n; i++)
cin >> a[i] >> b[i] >> c[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
if (i == 0) {
if (j == 0)
dp[i % 2][j] = a[i];
else if (j == 1)
dp[i % 2][j] = b[i];
else if (j == 2)
dp[i % 2][j] = c[i];
} else {
for (int k = 0; k < 3; k++) {
if (j == k)
continue;
if (j == 0)
dp[i % 2][j] = max(dp[i % 2][j], dp[(i - 1) % 2][k] + a[i]);
else if (j == 1)
dp[i % 2][j] = max(dp[i % 2][j], dp[(i - 1) % 2][k] + b[i]);
else if (j == 2)
dp[i % 2][j] = max(dp[i % 2][j], dp[(i - 1) % 2][k] + c[i]);
}
}
}
}
int ret = 0;
ret = max(dp[(n - 1) % 2][0], dp[(n - 1) % 2][1]);
ret = max(ret, dp[(n - 1) % 2][2]);
cout << ret;
}
| [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"call.arguments.change",
"assignment.change"
] | 962,715 | 962,716 | u001462978 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int dp[2][3];
int main() {
int n;
cin >> n;
int a[n], b[n], c[n];
for (int i = 0; i < n; i++)
cin >> a[i] >> b[i] >> c[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
if (i == 0) {
if (j == 0)
dp[i % 2][j] = a[i];
else if (j == 1)
dp[i % 2][j] = b[i];
else if (j == 2)
dp[i % 2][j] = c[i];
} else {
for (int k = 0; k < 3; k++) {
if (j == k)
continue;
if (j == 0)
dp[i % 2][j] = max(dp[i % 2][j], dp[(i - 1) % 2][k] + a[i]);
else if (j == 1)
dp[i % 2][j] = max(dp[i % 2][j], dp[(i - 1) % 2][k] + b[i]);
else if (j == 2)
dp[i % 2][j] = max(dp[i % 2][j], dp[(i - 1) % 2][k] + c[i]);
}
}
}
}
int ret = 0;
ret = max(dp[(n - 1) % 2][0], dp[n - 1][1]);
ret = max(ret, dp[(n - 1) % 2][2]);
cout << ret;
}
| #include <bits/stdc++.h>
using namespace std;
int dp[2][3];
int main() {
int n;
cin >> n;
int a[n], b[n], c[n];
for (int i = 0; i < n; i++)
cin >> a[i] >> b[i] >> c[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
if (i == 0) {
if (j == 0)
dp[i % 2][j] = a[i];
else if (j == 1)
dp[i % 2][j] = b[i];
else if (j == 2)
dp[i % 2][j] = c[i];
} else {
for (int k = 0; k < 3; k++) {
if (j == k)
continue;
if (j == 0)
dp[i % 2][j] = max(dp[i % 2][j], dp[(i - 1) % 2][k] + a[i]);
else if (j == 1)
dp[i % 2][j] = max(dp[i % 2][j], dp[(i - 1) % 2][k] + b[i]);
else if (j == 2)
dp[i % 2][j] = max(dp[i % 2][j], dp[(i - 1) % 2][k] + c[i]);
}
}
}
}
int ret = 0;
ret = max(dp[(n - 1) % 2][0], dp[(n - 1) % 2][1]);
ret = max(ret, dp[(n - 1) % 2][2]);
cout << ret;
}
| [
"call.arguments.change",
"assignment.change"
] | 962,717 | 962,716 | u001462978 | cpp |
p03162 | #include "bits/stdc++.h"
using namespace std;
void solve() {
int n;
cin >> n;
int a[n][3];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> a[i][j];
}
}
vector<vector<int>> dp(n, vector<int>(3, 0));
dp[0][0] = a[0][0];
dp[0][1] = a[0][1];
dp[0][2] = a[0][2];
for (int i = 1; i < n; i++) {
dp[i][0] = max(dp[i - 1][1], dp[i - 1][2]) + a[i][0];
dp[i][1] = max(dp[i - 1][0], dp[i - 1][2]) + a[i][1];
dp[i][2] = max(dp[i - 1][0], dp[i - 1][1]) + a[i][2];
}
cout << *max_element(dp.back().begin(), dp.back().end());
}
int main() {
solve();
return 0;
} | #include "bits/stdc++.h"
using namespace std;
void solve() {
int n;
cin >> n;
int a[n][3];
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
cin >> a[i][j];
}
}
vector<vector<int>> dp(n, vector<int>(3, 0));
dp[0][0] = a[0][0];
dp[0][1] = a[0][1];
dp[0][2] = a[0][2];
for (int i = 1; i < n; i++) {
dp[i][0] = max(dp[i - 1][1], dp[i - 1][2]) + a[i][0];
dp[i][1] = max(dp[i - 1][0], dp[i - 1][2]) + a[i][1];
dp[i][2] = max(dp[i - 1][0], dp[i - 1][1]) + a[i][2];
}
cout << *max_element(dp.back().begin(), dp.back().end());
}
int main() {
solve();
return 0;
} | [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 962,720 | 962,721 | u965895743 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
const int N = 1e5 + 5;
int a[5][N];
int dp[5][N];
int n;
int solve(int idx, int prev) {
if (idx == n + 1) {
return 0;
}
int &ans = dp[prev][idx];
if (ans != -1) {
return ans;
}
ans = 0;
for (int i = 1; i <= 3; i++) {
if (i == prev) {
continue;
}
ans = max(ans, a[i][idx] + solve(idx + 1, i));
}
return ans;
}
int32_t main() {
memset(dp, -1, sizeof(dp));
cin >> n;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= 3; j++) {
cin >> a[i][j];
}
}
int ans = solve(1, 0);
cout << ans << "\n";
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
#define endl "\n"
const int N = 1e5 + 5;
int a[5][N];
int dp[5][N];
int n;
int solve(int idx, int prev) {
if (idx == n + 1) {
return 0;
}
int &ans = dp[prev][idx];
if (ans != -1) {
return ans;
}
ans = 0;
for (int i = 1; i <= 3; i++) {
if (i == prev) {
continue;
}
ans = max(ans, a[i][idx] + solve(idx + 1, i));
}
return ans;
}
int32_t main() {
memset(dp, -1, sizeof(dp));
cin >> n;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= 3; j++) {
cin >> a[j][i];
}
}
int ans = solve(1, 0);
cout << ans << "\n";
return 0;
}
| [
"identifier.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 962,724 | 962,725 | u302685914 | cpp |
p03162 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int INF = 1001001001;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
int n;
cin >> n;
vector<vector<int>> a(n, vector<int>(3));
rep(i, n) rep(j, 3) cin >> a[i][j];
vector<vector<int>> dp(n + 1, vector<int>(3));
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
if (j == k)
continue;
chmax(dp[i][j], dp[i - 1][k] + a[i][j]);
}
}
}
int ans = 0;
rep(i, 3) chmax(ans, dp[n][i]);
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int INF = 1001001001;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
int n;
cin >> n;
vector<vector<int>> a(n, vector<int>(3));
rep(i, n) rep(j, 3) cin >> a[i][j];
vector<vector<int>> dp(n + 1, vector<int>(3));
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
if (j == k)
continue;
chmax(dp[i][j], dp[i - 1][k] + a[i - 1][j]);
}
}
}
int ans = 0;
rep(i, 3) chmax(ans, dp[n][i]);
cout << ans << endl;
return 0;
} | [
"expression.operation.binary.add"
] | 962,728 | 962,729 | u005006157 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define intl long long
void fastio() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
int main() {
intl n;
cin >> n;
intl a[n + 1][4];
for (intl i = 1; i <= n; i++) {
for (intl j = 1; j <= 3; j++) {
cin >> a[i][j];
}
}
intl dp[n + 1][4];
dp[1][1] = a[1][1];
dp[1][2] = a[1][2];
dp[1][3] = a[1][3];
if (n > 1) {
for (intl i = 2; i <= n; i++) {
for (intl j = 1; j <= 3; j++) {
if (j == 1) {
dp[i][j] = a[i][j] + max(dp[i - 1][j + 1], dp[i - 1][j + 2]);
}
if (j == 2) {
dp[i][j] = a[i][j] + max(dp[i - 1][j - 1], dp[i - 1][j + 1]);
}
if (j == 3) {
dp[i][j] = a[i][j] + max(dp[i - 1][j - 1], dp[i - 1][j - 2]);
}
}
cout << max(dp[n][3], max(dp[n][2], dp[n][1]));
}
} else {
// for(intl i=1;i<=n;i++)
// {
// for(intl j=1;j<=3;j++)
// {
// cout<<dp[i][j]<<" ";
// }
// cout<<endl;
// }
cout << max(dp[n][3], max(dp[n][2], dp[n][1]));
}
} | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define intl long long
void fastio() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
int main() {
intl n;
cin >> n;
intl a[n + 1][4];
for (intl i = 1; i <= n; i++) {
for (intl j = 1; j <= 3; j++) {
cin >> a[i][j];
}
}
intl dp[n + 1][4];
dp[1][1] = a[1][1];
dp[1][2] = a[1][2];
dp[1][3] = a[1][3];
if (n > 1) {
for (intl i = 2; i <= n; i++) {
for (intl j = 1; j <= 3; j++) {
if (j == 1) {
dp[i][j] = a[i][j] + max(dp[i - 1][j + 1], dp[i - 1][j + 2]);
}
if (j == 2) {
dp[i][j] = a[i][j] + max(dp[i - 1][j - 1], dp[i - 1][j + 1]);
}
if (j == 3) {
dp[i][j] = a[i][j] + max(dp[i - 1][j - 1], dp[i - 1][j - 2]);
}
}
}
cout << max(dp[n][3], max(dp[n][2], dp[n][1]));
} else {
cout << max(dp[n][3], max(dp[n][2], dp[n][1]));
}
// for(intl i=1;i<=n;i++)
// {
// for(intl j=1;j<=3;j++)
// {
// cout<<dp[i][j]<<" ";
// }
// cout<<endl;
// }
} | [] | 962,730 | 962,731 | u025753638 | cpp |
p03162 | #include <bits/stdc++.h>
#define ll long long int
#define fin for (i = 0; i < n; i++)
#define vec vector<ll>
#define pb push_back
#define vecit vector<ll>::iterator
#define vecp vector<pair<ll, ll>>
#define vecpit vector<pair<ll, ll>>::iterator
#define mapp map<ll, ll>
#define mapr map<ll, pair<ll, ll>>
#define maprit map<ll, pair<ll, ll>>::iterator
#define mapit map<ll, ll>::iterator
#define mod1 1000000007
#define INF 1000000000000
using namespace std;
int main() {
ll n;
cin >> n;
ll i, k, j, l;
ll map1[n][4];
map1[0][1] = 0;
map1[0][2] = 0;
map1[0][3] = 0;
for (i = 1; i <= n; i++) {
cin >> j >> k >> l;
map1[i][1] = j + max(map1[i - 1][2], map1[i - 1][3]);
map1[i][2] = k + max(map1[i - 1][1], map1[i - 1][3]);
map1[i][3] = l + max(map1[i - 1][2], map1[i - 1][1]);
}
cout << max(max(map1[i - 1][1], map1[i - 1][2]), map1[i - 1][3]);
}
| #include <bits/stdc++.h>
#define ll long long int
#define fin for (i = 0; i < n; i++)
#define vec vector<ll>
#define pb push_back
#define vecit vector<ll>::iterator
#define vecp vector<pair<ll, ll>>
#define vecpit vector<pair<ll, ll>>::iterator
#define mapp map<ll, ll>
#define mapr map<ll, pair<ll, ll>>
#define maprit map<ll, pair<ll, ll>>::iterator
#define mapit map<ll, ll>::iterator
#define mod1 1000000007
#define INF 1000000000000
using namespace std;
int main() {
ll n;
cin >> n;
ll i, k, j, l;
ll map1[n + 1][4];
map1[0][1] = 0;
map1[0][2] = 0;
map1[0][3] = 0;
for (i = 1; i <= n; i++) {
cin >> j >> k >> l;
map1[i][1] = j + max(map1[i - 1][2], map1[i - 1][3]);
map1[i][2] = k + max(map1[i - 1][1], map1[i - 1][3]);
map1[i][3] = l + max(map1[i - 1][2], map1[i - 1][1]);
}
cout << max(max(map1[i - 1][1], map1[i - 1][2]), map1[i - 1][3]);
}
| [
"variable_declaration.array_dimensions.change",
"expression.operation.binary.add"
] | 962,732 | 962,733 | u524252607 | cpp |
p03162 | #include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define MOD 1000000007
#define endl "\n"
using namespace std;
int main() {
int n;
cin >> n;
int arr[n][3];
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
cin >> arr[i][j];
}
}
int dp[n][3];
for (int j = 0; j < 3; j++)
dp[0][j] = arr[0][j];
for (int i = 1; i < n; i++) {
for (int j = 0; j < 3; j++) {
int maxi = INT_MIN;
for (int k = 0; k < 3; k++) {
if (j != k)
maxi = max(arr[i - 1][k], maxi);
}
dp[i][j] = maxi + arr[i][j];
}
}
int maxi = INT_MIN;
for (int j = 0; j < 3; j++)
maxi = max(maxi, dp[n - 1][j]);
cout << maxi << endl;
}
| #include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define MOD 1000000007
#define endl "\n"
using namespace std;
int main() {
int n;
cin >> n;
int arr[n][3];
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
cin >> arr[i][j];
}
}
int dp[n][3];
for (int j = 0; j < 3; j++)
dp[0][j] = arr[0][j];
for (int i = 1; i < n; i++) {
for (int j = 0; j < 3; j++) {
int maxi = INT_MIN;
for (int k = 0; k < 3; k++) {
if (j != k)
maxi = max(dp[i - 1][k], maxi);
}
dp[i][j] = maxi + arr[i][j];
}
}
int maxi = INT_MIN;
for (int j = 0; j < 3; j++)
maxi = max(maxi, dp[n - 1][j]);
cout << maxi << endl;
}
| [
"assignment.value.change",
"call.arguments.change"
] | 962,734 | 962,735 | u213082454 | cpp |
p03162 | #include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define MOD 1000000007
#define endl "\n"
using namespace std;
int main() {
int n;
cin >> n;
int arr[n][3];
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
cin >> arr[i][j];
}
}
int dp[n][3];
for (int j = 0; j < 3; j++)
dp[0][j] = arr[0][j];
for (int i = 1; i < n; i++) {
for (int j = 0; j < 3; j++) {
int maxi = INT_MIN;
for (int k = 0; k < 3; k++) {
if (j != k)
maxi = max(arr[i - 1][j], maxi);
}
dp[i][j] = maxi + arr[i][j];
}
}
int maxi = INT_MIN;
for (int j = 0; j < 3; j++)
maxi = max(maxi, dp[n - 1][j]);
cout << maxi << endl;
}
| #include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define MOD 1000000007
#define endl "\n"
using namespace std;
int main() {
int n;
cin >> n;
int arr[n][3];
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
cin >> arr[i][j];
}
}
int dp[n][3];
for (int j = 0; j < 3; j++)
dp[0][j] = arr[0][j];
for (int i = 1; i < n; i++) {
for (int j = 0; j < 3; j++) {
int maxi = INT_MIN;
for (int k = 0; k < 3; k++) {
if (j != k)
maxi = max(dp[i - 1][k], maxi);
}
dp[i][j] = maxi + arr[i][j];
}
}
int maxi = INT_MIN;
for (int j = 0; j < 3; j++)
maxi = max(maxi, dp[n - 1][j]);
cout << maxi << endl;
}
| [
"assignment.value.change",
"call.arguments.change",
"identifier.change",
"variable_access.subscript.index.change"
] | 962,736 | 962,735 | u213082454 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int v1, v2, v3;
int arr[3][n];
for (int i = 0; i < n; i++) {
cin >> arr[i][0] >> arr[i][1] >> arr[i][2];
}
v1 = arr[0][0];
v2 = arr[0][1];
v3 = arr[0][2];
for (int i = 1; i < n; i++) {
int temp1 = v1;
int temp2 = v2;
int temp3 = v3;
v1 = arr[i][0] + max(temp2, temp3);
v2 = arr[i][1] + max(temp1, temp3);
v3 = arr[i][2] + max(temp1, temp2);
}
cout << max(max(v1, v2), v3) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int v1, v2, v3;
int arr[n][3];
for (int i = 0; i < n; i++) {
cin >> arr[i][0] >> arr[i][1] >> arr[i][2];
}
v1 = arr[0][0];
v2 = arr[0][1];
v3 = arr[0][2];
for (int i = 1; i < n; i++) {
int temp1 = v1;
int temp2 = v2;
int temp3 = v3;
v1 = arr[i][0] + max(temp2, temp3);
v2 = arr[i][1] + max(temp1, temp3);
v3 = arr[i][2] + max(temp1, temp2);
}
cout << max(max(v1, v2), v3) << endl;
return 0;
} | [
"identifier.replace.add",
"literal.replace.remove",
"variable_declaration.array_dimensions.change",
"identifier.replace.remove",
"literal.replace.add"
] | 962,737 | 962,738 | u484382859 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int a[100000][3];
int dp[100000][3];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
cin >> a[i][j];
}
}
dp[0][0] = a[0][0];
dp[0][1] = a[0][1];
dp[0][2] = a[0][2];
for (int day = 1; day < n; day++) {
dp[day][0] = a[day][0] + max(a[day - 1][1], a[day - 1][2]);
dp[day][1] = a[day][1] + max(a[day - 1][0], a[day - 1][2]);
dp[day][2] = a[day][2] + max(a[day - 1][0], a[day - 1][1]);
}
int answer = max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2]));
cout << answer;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int a[100000][3];
int dp[100000][3];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
cin >> a[i][j];
}
}
dp[0][0] = a[0][0];
dp[0][1] = a[0][1];
dp[0][2] = a[0][2];
for (int day = 1; day < n; day++) {
dp[day][0] = a[day][0] + max(dp[day - 1][1], dp[day - 1][2]);
dp[day][1] = a[day][1] + max(dp[day - 1][0], dp[day - 1][2]);
dp[day][2] = a[day][2] + max(dp[day - 1][0], dp[day - 1][1]);
}
int answer = max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2]));
cout << answer;
return 0;
} | [
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 962,739 | 962,740 | u174584859 | cpp |
p03162 | #include "bits/stdc++.h"
using namespace std;
using ll = long long;
#define endl '\n'
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<int> dp(3, 0);
for (int day = 0; day < n; ++day) {
vector<int> h(3), new_dp(3, 0);
for (int &x : h)
cin >> x;
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 3; ++j) {
if (i != j) {
new_dp[j] = (new_dp[j], dp[i] + h[j]);
}
}
}
dp = new_dp;
}
cout << *max_element(dp.begin(), dp.end()) << endl;
return 0;
} | #include "bits/stdc++.h"
using namespace std;
using ll = long long;
#define endl '\n'
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<int> dp(3, 0);
for (int day = 0; day < n; ++day) {
vector<int> h(3), new_dp(3, 0);
for (int &x : h)
cin >> x;
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 3; ++j) {
if (i != j) {
new_dp[j] = max(new_dp[j], dp[i] + h[j]);
}
}
}
dp = new_dp;
}
cout << *max_element(dp.begin(), dp.end()) << endl;
return 0;
} | [
"call.add"
] | 962,752 | 962,753 | u328888869 | cpp |
p03162 | #include "bits/stdc++.h"
using namespace std;
using ll = long long;
#define endl '\n'
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<vector<int>> h(n, vector<int>(3));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < 3; ++j)
cin >> h[i][j];
}
vector<vector<int>> dp(n, vector<int>(3, -1));
for (int i = 0; i < 3; ++i)
dp[0][i] = h[0][i];
for (int i = 1; i < n; ++i) {
for (int j = 0; j < 3; ++j) {
for (int k = 0; k < 3; ++k) {
if (j != k)
dp[i][j] = max(dp[i][j], dp[i - 1][j] + h[i][k]);
}
}
}
cout << max({dp[n - 1][0], dp[n - 1][1], dp[n - 1][2]}) << endl;
return 0;
} | #include "bits/stdc++.h"
using namespace std;
using ll = long long;
#define endl '\n'
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<vector<int>> h(n, vector<int>(3));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < 3; ++j)
cin >> h[i][j];
}
vector<vector<int>> dp(n, vector<int>(3, -1));
for (int i = 0; i < 3; ++i)
dp[0][i] = h[0][i];
for (int i = 1; i < n; ++i) {
for (int j = 0; j < 3; ++j) {
for (int k = 0; k < 3; ++k) {
if (j != k)
dp[i][k] = max(dp[i][k], dp[i - 1][j] + h[i][k]);
}
}
}
cout << max({dp[n - 1][0], dp[n - 1][1], dp[n - 1][2]}) << endl;
return 0;
} | [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change",
"assignment.value.change",
"call.arguments.change"
] | 962,754 | 962,755 | u328888869 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
long long hasil[100005][5];
int main() {
int n;
scanf("%d", &n);
long long data[n + 1][5];
for (int i = 1; i <= n; i++) {
scanf("%lld %lld %lld", &data[i][1], &data[i][2], &data[i][3]);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j < 4; j++) {
for (int k = 1; k < 4; k++) {
if (k != j) {
if ((hasil[i][j] == 0) ||
(hasil[i][j] < hasil[i - 1][k] + data[i][j]))
hasil[i][j] = hasil[i - 1][k] + data[i][j];
}
}
}
}
int tmp = 1;
for (int i = 1; i < 4; i++) {
if (hasil[n][i] > hasil[n][tmp])
tmp = i;
swap(hasil[n][1], hasil[n][tmp]);
}
printf("%lld\n", hasil[n][1]);
}
| #include <bits/stdc++.h>
using namespace std;
long long hasil[100005][5];
int main() {
int n;
scanf("%d", &n);
long long data[n + 1][5];
for (int i = 1; i <= n; i++) {
scanf("%lld %lld %lld", &data[i][1], &data[i][2], &data[i][3]);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j < 4; j++) {
for (int k = 1; k < 4; k++) {
if (k != j) {
if ((hasil[i][j] == 0) ||
(hasil[i][j] < hasil[i - 1][k] + data[i][j]))
hasil[i][j] = hasil[i - 1][k] + data[i][j];
}
}
}
}
int tmp = 1;
for (int i = 1; i < 4; i++) {
if (hasil[n][i] > hasil[n][tmp])
tmp = i;
}
swap(hasil[n][1], hasil[n][tmp]);
printf("%lld\n", hasil[n][1]);
}
| [] | 962,778 | 962,779 | u027968711 | cpp |
p03162 | ////=====BIsmillahir Rahmanir Rahim =====////
/* ______
_______ /\ |``\ | | /
| / \ |__/ |____ |/
| / _ _\ | \ | |\
| / \ | \ |______ | \
Dept. of CSE
Comilla University
*/
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/detail/standard_policies.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define fi 2 * acos(0.0)
#define ee 2.71828
#define ll long long
#define FIO \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define Node struct node
#define spc " "
#define E 2.71828182845904523536
#define pb push_back
#define pp pop_back
#define ff first
#define ss second
#define valid(nx, ny) nx >= 0 && nx < n &&ny >= 0 && ny < m
#define edl printf("\n")
#define infinity 1e16
#define mod 1000000007
#define cn continue
#define csprint1 printf("Case %lld: ", cs++)
#define csprint2 printf("Case %lld:\n", cs++)
#define sf(a) scanf("%lld", &a)
#define sff(a, b) scanf("%lld %lld", &a, &b)
#define sfff(a, b, c) scanf("%lld %lld %lld", &a, &b, &c)
#define sffff(a, b, c, d) scanf("%lld %lld %lld %lld", &a, &b, &c, &d)
#define all(v) v.begin(), v.end()
#define pfn(a) printf("%lld\n", a)
#define pfs(a) printf("%lld ", a)
using namespace __gnu_pbds;
using namespace std;
typedef pair<ll, ll> pl;
typedef vector<int> vi;
typedef vector<pl> vpi;
typedef vector<pl> vpl;
typedef tree<pair<ll, int>, null_type, less<pair<ll, int>>, rb_tree_tag,
tree_order_statistics_node_update>
ost;
#define error(args...) \
{ \
string _s = #args; \
replace(_s.begin(), _s.end(), ',', ' '); \
stringstream _ss(_s); \
istream_iterator<string> _it(_ss); \
err(_it, args); \
}
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << "," << spc;
err(++it, args...);
cout << edl;
}
/// Bit manipulation
bool checkbit(int mask, int bit) { return mask & (1 << bit); }
int setbit(int mask, int bit) { return mask | (1 << bit); }
int clearbit(int mask, int bit) { return mask & ~(1 << bit); }
int togglebit(int mask, int bit) { return mask ^ (1 << bit); }
int bitno(int mask) { return (int)__builtin_popcount(mask); }
/*----------------------Graph Moves----------------*/
const int fx[] = {+1, -1, +0, +0};
const int fy[] = {+0, +0, +1, -1};
// const int fx[]={+0,+0,+1,-1,-1,+1,-1,+1}; // Kings Move
// const int fy[]={-1,+1,+0,+0,+1,+1,-1,-1}; // Kings Move
// const int fx[]={-2, -2, -1, -1, 1, 1, 2, 2}; // Knights Move
// const int fy[]={-1, 1, -2, 2, -2, 2, -1, 1}; // Knights Move
/*------------------------------------------------*/
///=====================================///
const int maX = 1e5 + 10;
ll dp[maX][4];
int main() {
ll n;
sf(n);
for (ll i = 1; i <= n; i += 1) {
ll a, b, c;
sfff(a, b, c);
if (i == 1) {
dp[i][1] = a, dp[i][2] = b, dp[i][3] = c;
} else {
dp[i][1] = max(dp[i - 1][2] + b, dp[i - 1][3] + b);
dp[i][2] = max(dp[i - 1][1] + a, dp[i - 1][3] + a);
dp[i][3] = max(dp[i - 1][1] + c, dp[i - 1][2] + c);
}
// cout<<dp[i][1]<<spc<<dp[i][2]<<spc<<dp[i][3]<<endl;
}
ll mx = -1;
mx = max({dp[n][1], dp[n][2], dp[n][3]});
pfn(mx);
return 0;
}
| ////=====BIsmillahir Rahmanir Rahim =====////
/* ______
_______ /\ |``\ | | /
| / \ |__/ |____ |/
| / _ _\ | \ | |\
| / \ | \ |______ | \
Dept. of CSE
Comilla University
*/
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/detail/standard_policies.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define fi 2 * acos(0.0)
#define ee 2.71828
#define ll long long
#define FIO \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define Node struct node
#define spc " "
#define E 2.71828182845904523536
#define pb push_back
#define pp pop_back
#define ff first
#define ss second
#define valid(nx, ny) nx >= 0 && nx < n &&ny >= 0 && ny < m
#define edl printf("\n")
#define infinity 1e16
#define mod 1000000007
#define cn continue
#define csprint1 printf("Case %lld: ", cs++)
#define csprint2 printf("Case %lld:\n", cs++)
#define sf(a) scanf("%lld", &a)
#define sff(a, b) scanf("%lld %lld", &a, &b)
#define sfff(a, b, c) scanf("%lld %lld %lld", &a, &b, &c)
#define sffff(a, b, c, d) scanf("%lld %lld %lld %lld", &a, &b, &c, &d)
#define all(v) v.begin(), v.end()
#define pfn(a) printf("%lld\n", a)
#define pfs(a) printf("%lld ", a)
using namespace __gnu_pbds;
using namespace std;
typedef pair<ll, ll> pl;
typedef vector<int> vi;
typedef vector<pl> vpi;
typedef vector<pl> vpl;
typedef tree<pair<ll, int>, null_type, less<pair<ll, int>>, rb_tree_tag,
tree_order_statistics_node_update>
ost;
#define error(args...) \
{ \
string _s = #args; \
replace(_s.begin(), _s.end(), ',', ' '); \
stringstream _ss(_s); \
istream_iterator<string> _it(_ss); \
err(_it, args); \
}
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << "," << spc;
err(++it, args...);
cout << edl;
}
/// Bit manipulation
bool checkbit(int mask, int bit) { return mask & (1 << bit); }
int setbit(int mask, int bit) { return mask | (1 << bit); }
int clearbit(int mask, int bit) { return mask & ~(1 << bit); }
int togglebit(int mask, int bit) { return mask ^ (1 << bit); }
int bitno(int mask) { return (int)__builtin_popcount(mask); }
/*----------------------Graph Moves----------------*/
const int fx[] = {+1, -1, +0, +0};
const int fy[] = {+0, +0, +1, -1};
// const int fx[]={+0,+0,+1,-1,-1,+1,-1,+1}; // Kings Move
// const int fy[]={-1,+1,+0,+0,+1,+1,-1,-1}; // Kings Move
// const int fx[]={-2, -2, -1, -1, 1, 1, 2, 2}; // Knights Move
// const int fy[]={-1, 1, -2, 2, -2, 2, -1, 1}; // Knights Move
/*------------------------------------------------*/
///=====================================///
const int maX = 1e5 + 10;
ll dp[maX][4];
int main() {
ll n;
sf(n);
for (ll i = 1; i <= n; i += 1) {
ll a, b, c;
sfff(a, b, c);
if (i == 1) {
dp[i][1] = a, dp[i][2] = b, dp[i][3] = c;
} else {
dp[i][1] = max(dp[i - 1][2] + a, dp[i - 1][3] + a);
dp[i][2] = max(dp[i - 1][1] + b, dp[i - 1][3] + b);
dp[i][3] = max(dp[i - 1][1] + c, dp[i - 1][2] + c);
}
// cout<<dp[i][1]<<spc<<dp[i][2]<<spc<<dp[i][3]<<endl;
}
ll mx = -1;
mx = max({dp[n][1], dp[n][2], dp[n][3]});
pfn(mx);
return 0;
}
| [
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 962,783 | 962,784 | u164081575 | cpp |
p03162 | #pragma region Header
#ifdef DEBUG
#include "debug.hpp"
#else
#define NDEBUG
#define debug(...)
#define IFD(...)
#endif
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdint>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdexcept>
#include <string>
#include <tuple>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
using i32 = int32_t;
using i64 = int64_t;
using u32 = uint32_t;
using u64 = uint64_t;
#define rep(i, n) for (int i = 0; i < static_cast<int>(n); ++i)
#define repd(i, n) for (int i = static_cast<int>(n) - 1; i >= 0; --i)
#define FOR(i, a, b) \
for (int i = static_cast<int>(a); i <= static_cast<int>(b); ++i)
#define FORD(i, b, a) \
for (int i = static_cast<int>(b); i >= static_cast<int>(a); --i)
template <typename T> int SZ(T const &x) { return static_cast<int>(x.size()); }
template <class T> bool chmax(T &a, T const &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, T const &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
#pragma endregion
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout << fixed << setprecision(15);
int n;
cin >> n;
vector h_s(n, vector(3, 0));
rep(i, n) { cin >> h_s[i][0] >> h_s[i][1] >> h_s[i][2]; }
// i日後の幸福度
vector<int> dp(3), dptmp(3);
dp = {0, 0, 0};
rep(i, n) {
dptmp = dp;
rep(j, 3) {
dptmp[j] = max(dp[(j + 1) % 3] + h_s[i][(j + 1) % 3],
dptmp[(j + 2) % 3] + h_s[i][(j + 2) % 3]);
}
swap(dp, dptmp);
}
cout << max({dp[0], dp[1], dp[2]}) << '\n';
return 0;
}
| #pragma region Header
#ifdef DEBUG
#include "debug.hpp"
#else
#define NDEBUG
#define debug(...)
#define IFD(...)
#endif
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdint>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdexcept>
#include <string>
#include <tuple>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
using i32 = int32_t;
using i64 = int64_t;
using u32 = uint32_t;
using u64 = uint64_t;
#define rep(i, n) for (int i = 0; i < static_cast<int>(n); ++i)
#define repd(i, n) for (int i = static_cast<int>(n) - 1; i >= 0; --i)
#define FOR(i, a, b) \
for (int i = static_cast<int>(a); i <= static_cast<int>(b); ++i)
#define FORD(i, b, a) \
for (int i = static_cast<int>(b); i >= static_cast<int>(a); --i)
template <typename T> int SZ(T const &x) { return static_cast<int>(x.size()); }
template <class T> bool chmax(T &a, T const &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, T const &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
#pragma endregion
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout << fixed << setprecision(15);
int n;
cin >> n;
vector h_s(n, vector(3, 0));
rep(i, n) { cin >> h_s[i][0] >> h_s[i][1] >> h_s[i][2]; }
// i日後の幸福度
vector<int> dp(3), dptmp(3);
dp = {0, 0, 0};
rep(i, n) {
// dptmp = dp;
rep(j, 3) {
dptmp[j] = max(dp[(j + 1) % 3] + h_s[i][(j + 1) % 3],
dp[(j + 2) % 3] + h_s[i][(j + 2) % 3]);
}
swap(dp, dptmp);
}
cout << max({dp[0], dp[1], dp[2]}) << '\n';
return 0;
}
| [
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 962,791 | 962,792 | u869306730 | cpp |
p03162 | #include <array>
#include <iostream>
#include <limits>
#include <vector>
using namespace std;
typedef long ll;
int main() {
ll n;
cin >> n;
vector<array<ll, 3>> nums(n);
for (auto &e : nums) {
for (auto &a : e)
cin >> a;
}
// cout << "done" << endl;
vector<array<ll, 3>> dp(n);
dp[0][0] = nums[0][0];
dp[0][1] = nums[0][2];
dp[0][2] = nums[0][2];
for (ll i = 1; i < n; i++) {
for (ll prev = 0; prev < 3; prev++)
for (ll curr = 0; curr < 3; curr++)
if (curr != prev) {
dp[i][curr] = max(dp[i][curr], nums[i][curr] + dp[i - 1][prev]);
}
}
ll res = 0;
for (ll i = 0; i < 3; i++)
res = max(res, dp[n - 1][i]);
cout << res << endl;
} | #include <array>
#include <iostream>
#include <limits>
#include <vector>
using namespace std;
typedef long ll;
int main() {
ll n;
cin >> n;
vector<array<ll, 3>> nums(n);
for (auto &e : nums) {
for (auto &a : e)
cin >> a;
}
// cout << "done" << endl;
vector<array<ll, 3>> dp(n);
dp[0][0] = nums[0][0];
dp[0][1] = nums[0][1];
dp[0][2] = nums[0][2];
for (ll i = 1; i < n; i++) {
for (ll prev = 0; prev < 3; prev++)
for (ll curr = 0; curr < 3; curr++)
if (curr != prev) {
dp[i][curr] = max(dp[i][curr], nums[i][curr] + dp[i - 1][prev]);
}
}
ll res = 0;
for (ll i = 0; i < 3; i++)
res = max(res, dp[n - 1][i]);
cout << res << endl;
} | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change"
] | 962,795 | 962,796 | u121525338 | cpp |
p03162 | /*
!!~~~~~~~~~~~~~~~~~~
#include < ~_~ Ajay >
~~~~~~~~~~~~~~~~~~~~!!
*/
#include <algorithm>
#include <climits>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <vector>
using namespace std;
#define int long long
#define lmax LLONG_MAX
#define lmin LLONG_MIN
#define pb push_back
#define mp make_pair
#define f first
#define s second
#define vi vector<int>
#define vpii vector<pair<int, int>>
#define varr vector<int> v[1000000]
#define mii map<int, int>
#define msi map<string, int>
#define mlist map<int, list>
#define wloop \
int t; \
cin >> t; \
while (t--)
#define forxNi(x, n) for (int i = x; i < n; i++)
#define forxNj(x, n) for (int j = x; j < n; j++)
#define forNxi(n, x) for (int i = n; i >= x; i--)
#define forNxj(n, x) for (int j = n; j >= x; j--)
#define fastio \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
//------Code begins--->
int32_t main() {
fastio;
int n;
cin >> n;
int a[n], b[n], c[n];
forxNi(0, n) { cin >> a[i] >> b[i] >> c[i]; }
int dp[n][3];
forxNi(0, n) {
forxNj(0, 3) { dp[i][j] = 0; }
}
dp[0][0] = a[0];
dp[0][1] = b[0];
dp[0][2] = c[0];
forxNi(1, n) {
dp[i][0] = a[i] + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = a[i] + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = a[i] + max(dp[i - 1][1], dp[i - 1][0]);
}
int maxim = lmin;
forxNi(0, 3) {
if (dp[n - 1][i] > maxim)
maxim = dp[n - 1][i];
}
cout << maxim;
cout << '\n';
return 0;
} | /*
!!~~~~~~~~~~~~~~~~~~
#include < ~_~ Ajay >
~~~~~~~~~~~~~~~~~~~~!!
*/
#include <algorithm>
#include <climits>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <vector>
using namespace std;
#define int long long
#define lmax LLONG_MAX
#define lmin LLONG_MIN
#define pb push_back
#define mp make_pair
#define f first
#define s second
#define vi vector<int>
#define vpii vector<pair<int, int>>
#define varr vector<int> v[1000000]
#define mii map<int, int>
#define msi map<string, int>
#define mlist map<int, list>
#define wloop \
int t; \
cin >> t; \
while (t--)
#define forxNi(x, n) for (int i = x; i < n; i++)
#define forxNj(x, n) for (int j = x; j < n; j++)
#define forNxi(n, x) for (int i = n; i >= x; i--)
#define forNxj(n, x) for (int j = n; j >= x; j--)
#define fastio \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
//------Code begins--->
int32_t main() {
fastio;
int n;
cin >> n;
int a[n], b[n], c[n];
forxNi(0, n) { cin >> a[i] >> b[i] >> c[i]; }
int dp[n][3];
forxNi(0, n) {
forxNj(0, 3) { dp[i][j] = 0; }
}
dp[0][0] = a[0];
dp[0][1] = b[0];
dp[0][2] = c[0];
forxNi(1, n) {
dp[i][0] = a[i] + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = b[i] + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = c[i] + max(dp[i - 1][1], dp[i - 1][0]);
}
int maxim = lmin;
forxNi(0, 3) {
if (dp[n - 1][i] > maxim)
maxim = dp[n - 1][i];
}
cout << maxim;
cout << '\n';
return 0;
} | [
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 962,801 | 962,802 | u969690971 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
int arr[n][3];
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++)
cin >> arr[i][j];
}
vector<vector<int>> dp(n, vector<int>(3, 0));
for (int i = 0; i < n; i++) {
dp[0][i] = arr[0][i];
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < 3; j++) {
if (j == 0)
dp[i][j] = arr[i][j] + max(dp[i - 1][1], dp[i - 1][2]);
if (j == 1)
dp[i][j] = arr[i][j] + max(dp[i - 1][0], dp[i - 1][2]);
if (j == 2)
dp[i][j] = arr[i][j] + max(dp[i - 1][0], dp[i - 1][1]);
}
}
cout << max({dp[n - 1][0], dp[n - 1][1], dp[n - 1][2]});
}
int main() {
int test;
// cin>>test;
test = 1;
while (test--) {
solve();
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
int arr[n][3];
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++)
cin >> arr[i][j];
}
vector<vector<int>> dp(n, vector<int>(3, 0));
for (int i = 0; i < 3; i++) {
dp[0][i] = arr[0][i];
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < 3; j++) {
if (j == 0)
dp[i][j] = arr[i][j] + max(dp[i - 1][1], dp[i - 1][2]);
if (j == 1)
dp[i][j] = arr[i][j] + max(dp[i - 1][0], dp[i - 1][2]);
if (j == 2)
dp[i][j] = arr[i][j] + max(dp[i - 1][0], dp[i - 1][1]);
}
}
/*for(int i=0;i<n;i++)
{
for(int j=0;j<3;j++)
cout<<dp[i][j]<<" ";
cout<<"\n";
}*/
cout << max({dp[n - 1][0], dp[n - 1][1], dp[n - 1][2]});
}
int main() {
int test;
// cin>>test;
test = 1;
while (test--) {
solve();
}
return 0;
}
| [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 962,806 | 962,807 | u157659681 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int func(int arr[][3], int n) {
int dp[n][3], maxval, i;
dp[0][0] = arr[0][0], dp[0][1] = arr[0][1], dp[0][2] = arr[0][2];
for (i = 0; i < n; i++) {
dp[i][0] = arr[i][0] + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = arr[i][1] + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = arr[i][2] + max(dp[i - 1][1], dp[i - 1][0]);
}
maxval = max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2]));
return maxval;
}
int main() {
int n, i, j;
cin >> n;
int arr[n][3];
for (i = 0; i < n; i++) {
for (j = 0; j < 3; j++) {
cin >> arr[i][j];
}
}
int val = func(arr, n);
cout << val;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int func(int arr[][3], int n) {
int dp[n][3], maxval, i;
dp[0][0] = arr[0][0], dp[0][1] = arr[0][1], dp[0][2] = arr[0][2];
for (i = 1; i < n; i++) {
dp[i][0] = arr[i][0] + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = arr[i][1] + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = arr[i][2] + max(dp[i - 1][1], dp[i - 1][0]);
}
maxval = max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2]));
return maxval;
}
int main() {
int n, i, j;
cin >> n;
int arr[n][3];
for (i = 0; i < n; i++) {
for (j = 0; j < 3; j++) {
cin >> arr[i][j];
}
}
int val = func(arr, n);
cout << val;
return 0;
}
| [
"literal.number.change",
"assignment.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 962,810 | 962,811 | u557086207 | cpp |
p03162 | #include <bits/stdc++.h>
#define int long long int
int dp[100010][3], a[100010][3], n;
using namespace std;
int solve(int i, int s) {
if (i == -1)
return 0;
if (dp[i][s] != -1)
return dp[i][s];
int m = 0;
for (int j = 0; j < 3; j++) {
if (j == s)
continue;
m = max(m, a[i][j] + solve(i - 1, j));
}
return dp[i][s] = m;
}
signed main() {
cin >> n;
memset(dp, -1, sizeof(dp));
for (int i = 0; i < n; i++)
cin >> a[i][0] >> a[i][1] >> a[i][2];
cout << max(a[n - 1][0] + solve(n - 2, 0),
max(a[n - 1][1] + solve(n - 2, 2), a[n - 1][2] + solve(n - 2, 2)))
<< "\n";
return 0;
} | #include <bits/stdc++.h>
#define int long long int
int dp[100010][3], a[100010][3], n;
using namespace std;
int solve(int i, int s) {
if (i == -1)
return 0;
if (dp[i][s] != -1)
return dp[i][s];
int m = 0;
for (int j = 0; j < 3; j++) {
if (j == s)
continue;
m = max(m, a[i][j] + solve(i - 1, j));
}
return dp[i][s] = m;
}
signed main() {
cin >> n;
memset(dp, -1, sizeof(dp));
for (int i = 0; i < n; i++)
cin >> a[i][0] >> a[i][1] >> a[i][2];
cout << max(a[n - 1][0] + solve(n - 2, 0),
max(a[n - 1][1] + solve(n - 2, 1), a[n - 1][2] + solve(n - 2, 2)))
<< "\n";
return 0;
} | [
"literal.number.change",
"io.output.change"
] | 962,817 | 962,818 | u772025386 | cpp |
p03162 | #include <bits/stdc++.h>
#define int long long int
int dp[100010][3], a[100010][3], n;
using namespace std;
int solve(int i, int s) {
if (i == -1)
return 0;
if (dp[i][s] != -1)
return dp[i][s];
int m = 0;
for (int j = 0; j < 3; j++) {
if (j == s)
continue;
m = max(m, a[i][j] + solve(i - 1, j));
}
return dp[i][s] = m;
}
signed main() {
cin >> n;
memset(dp, -1, sizeof(dp));
for (int i = 0; i < n; i++)
cin >> a[i][0] >> a[i][1] >> a[i][2];
cout << solve(n - 1, -1) << "\n";
return 0;
} | #include <bits/stdc++.h>
#define int long long int
int dp[100010][3], a[100010][3], n;
using namespace std;
int solve(int i, int s) {
if (i == -1)
return 0;
if (dp[i][s] != -1)
return dp[i][s];
int m = 0;
for (int j = 0; j < 3; j++) {
if (j == s)
continue;
m = max(m, a[i][j] + solve(i - 1, j));
}
return dp[i][s] = m;
}
signed main() {
cin >> n;
memset(dp, -1, sizeof(dp));
for (int i = 0; i < n; i++)
cin >> a[i][0] >> a[i][1] >> a[i][2];
cout << solve(n - 1, 3) << "\n";
return 0;
} | [
"literal.number.change",
"io.output.change",
"call.arguments.change"
] | 962,819 | 962,820 | u772025386 | cpp |
p03162 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <ctype.h>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <istream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <time.h>
#include <unordered_map>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define REP(i, a, b) for (int i = a; i < (b); ++i)
#define RREP(i, a, b) for (int i = a; i > (b); --i)
#define all(x) (x).begin(), (x).end()
#define YY cout << "Yes" << endl
#define NN cout << "No" << endl
const long long INF = 1000000007;
typedef long long ll;
using namespace std;
using Graph = vector<vector<int>>;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return (a * b) / gcd(a, b); }
ll dp[100010][3];
int v[100010][3];
int solve() {
int n;
cin >> n;
rep(i, n) rep(j, 3) cin >> v[i][j];
rep(i, 3) dp[0][i] = v[0][i];
REP(i, 1, n) {
rep(j, 3) {
rep(k, 3) {
if (j == k)
continue;
dp[i][j] = max(dp[i][j], dp[i - 1][j] + v[i][k]);
}
}
}
ll ans = 0;
rep(i, 3) ans = max(ans, dp[n - 1][i]);
cout << ans << endl;
return 0;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
// cout << fixed;cout << setprecision(16);
solve();
return 0;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <ctype.h>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <istream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <time.h>
#include <unordered_map>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define REP(i, a, b) for (int i = a; i < (b); ++i)
#define RREP(i, a, b) for (int i = a; i > (b); --i)
#define all(x) (x).begin(), (x).end()
#define YY cout << "Yes" << endl
#define NN cout << "No" << endl
const long long INF = 1000000007;
typedef long long ll;
using namespace std;
using Graph = vector<vector<int>>;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return (a * b) / gcd(a, b); }
ll dp[100010][3];
int v[100010][3];
int solve() {
int n;
cin >> n;
rep(i, n) rep(j, 3) cin >> v[i][j];
rep(i, 3) dp[0][i] = v[0][i];
REP(i, 1, n) {
rep(j, 3) {
rep(k, 3) {
if (j == k)
continue;
dp[i][k] = max(dp[i][k], dp[i - 1][j] + v[i][k]);
}
}
}
ll ans = 0;
rep(i, 3) ans = max(ans, dp[n - 1][i]);
cout << ans << endl;
return 0;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
// cout << fixed;cout << setprecision(16);
solve();
return 0;
} | [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change",
"assignment.value.change",
"call.arguments.change"
] | 962,887 | 962,890 | u820341516 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define fast \
ios_base::sync_with_stdio(0); \
cin.tie(NULL); \
cout.tie(NULL)
#define ordered_set \
tree<int, null_type, less<int>, rb_tree_tag, \
tree_order_statistics_node_update>
#define ll long long
#define ld long double
#define pb push_back
#define eb(a) emplace_back(a)
#define xx first
#define yy second
#define mp make_pair
#define pll pair<ll, ll>
#define mll map<ll, ll>
#define vll vector<ll>
#define pdd pair<double, double>
#define ALL(v) (v).begin(), (v).end()
const ll MOD = 1e9 + 7;
const ll inf = 1e18;
#define MODSET(d) \
if ((d) >= MOD) \
d %= MOD;
#define MODNEGSET(d) \
if ((d) < 0) \
d = ((d % MOD) + MOD) % MOD;
#define put(x) cout << #x << " = " << x << endl;
#define error(args...) \
{ \
string _s = #args; \
replace(_s.begin(), _s.end(), ',', ' '); \
stringstream _ss(_s); \
istream_iterator<string> _it(_ss); \
err(_it, args); \
}
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
err(++it, args...);
}
ll power(ll a, ll n) {
ll ans = 1;
while (n) {
if (n & 1)
ans = (ans * a);
n >>= 1;
a = (a * a);
}
return ans;
}
ll powerMod(ll a, ll n) {
ll ans = 1;
while (n) {
if (n & 1)
ans = (ans * a) % MOD;
n /= 2;
a = (a * a) % MOD;
}
return ans;
}
ll powerMod1(ll a, ll n, ll mod) {
ll ans = 1;
while (n) {
if (n & 1)
ans = (ans * a) % mod;
n >>= 1;
a = (a * a) % mod;
}
return ans;
}
ll lcm(ll a, ll b) { return a * (b / __gcd(a, b)); }
ll sumdigit(ll n) {
ll sum = 0;
while (n) {
sum += n % 10;
n = n / 10;
}
return sum;
}
ll countSetBit(ll a) { return __builtin_popcount(a); }
ll countBit(ll a) {
ll sum = 0;
while (a) {
sum++;
a >>= 1;
}
return sum;
}
ll length(ll a) {
ll ans = 0;
while (a) {
ans++;
a = a / 10;
}
return ans;
}
bool isVowel(char c) {
if (c == 'a' or c == 'e' or c == 'i' or c == 'o' or c == 'u')
return true;
return false;
}
ll sum(ll k) {
if (k < 0)
return 0;
return (k * (k + 1)) / 2;
}
struct FenwickTree {
int N;
vector<int> tree;
void init(int n) {
N = n;
tree.assign(n + 1, 0);
}
void update(int idx, int val) {
while (idx <= N) {
tree[idx] += val;
idx += idx & -idx;
}
}
void updateMax(int idx, int val) {
while (idx <= N) {
tree[idx] = max(tree[idx], val);
idx += idx & -idx;
}
}
int pref(int idx) {
int ans = 0;
while (idx > 0) {
ans += tree[idx];
idx -= idx & -idx;
}
return ans;
}
int rsum(int l, int r) { return pref(r) - pref(l - 1); }
int prefMax(int idx) {
int ans = -2e9;
while (idx > 0) {
ans = max(ans, tree[idx]);
idx -= idx & -idx;
}
return ans;
}
};
//~ const int MAXN = 1e6+10;
//~ std::vector <int> prime;
//~ bool is_composite[MAXN];
//~ void sieve (int n) {
//~ std::fill (is_composite, is_composite + n, false);
//~ for (int i = 2; i < n; ++i) {
//~ if (!is_composite[i]) prime.push_back (i);
//~ for (int j = 0; j < (int)prime.size () && i * prime[j] < n; ++j) {
//~ is_composite[i * prime[j]] = true;
//~ if (i % prime[j] == 0) break;
//~ }
//~ }
//~ }
const int INF = 1e9 + 10;
int main() {
fast;
ll t;
t = 1;
//~ cin>>t;
while (t--) {
int n;
cin >> n;
vector<int> dp(3, 0);
for (int day = 0; day < n; day++) {
vector<int> c(3);
vector<int> new_dp(3, 0);
for (int &it : c) {
cin >> it;
}
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (i != j) {
new_dp[j] = max(dp[j], dp[i] + c[j]);
}
}
}
dp = new_dp;
}
cout << max({dp[0], dp[2], dp[1]});
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define fast \
ios_base::sync_with_stdio(0); \
cin.tie(NULL); \
cout.tie(NULL)
#define ordered_set \
tree<int, null_type, less<int>, rb_tree_tag, \
tree_order_statistics_node_update>
#define ll long long
#define ld long double
#define pb push_back
#define eb(a) emplace_back(a)
#define xx first
#define yy second
#define mp make_pair
#define pll pair<ll, ll>
#define mll map<ll, ll>
#define vll vector<ll>
#define pdd pair<double, double>
#define ALL(v) (v).begin(), (v).end()
const ll MOD = 1e9 + 7;
const ll inf = 1e18;
#define MODSET(d) \
if ((d) >= MOD) \
d %= MOD;
#define MODNEGSET(d) \
if ((d) < 0) \
d = ((d % MOD) + MOD) % MOD;
#define put(x) cout << #x << " = " << x << endl;
#define error(args...) \
{ \
string _s = #args; \
replace(_s.begin(), _s.end(), ',', ' '); \
stringstream _ss(_s); \
istream_iterator<string> _it(_ss); \
err(_it, args); \
}
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
err(++it, args...);
}
ll power(ll a, ll n) {
ll ans = 1;
while (n) {
if (n & 1)
ans = (ans * a);
n >>= 1;
a = (a * a);
}
return ans;
}
ll powerMod(ll a, ll n) {
ll ans = 1;
while (n) {
if (n & 1)
ans = (ans * a) % MOD;
n /= 2;
a = (a * a) % MOD;
}
return ans;
}
ll powerMod1(ll a, ll n, ll mod) {
ll ans = 1;
while (n) {
if (n & 1)
ans = (ans * a) % mod;
n >>= 1;
a = (a * a) % mod;
}
return ans;
}
ll lcm(ll a, ll b) { return a * (b / __gcd(a, b)); }
ll sumdigit(ll n) {
ll sum = 0;
while (n) {
sum += n % 10;
n = n / 10;
}
return sum;
}
ll countSetBit(ll a) { return __builtin_popcount(a); }
ll countBit(ll a) {
ll sum = 0;
while (a) {
sum++;
a >>= 1;
}
return sum;
}
ll length(ll a) {
ll ans = 0;
while (a) {
ans++;
a = a / 10;
}
return ans;
}
bool isVowel(char c) {
if (c == 'a' or c == 'e' or c == 'i' or c == 'o' or c == 'u')
return true;
return false;
}
ll sum(ll k) {
if (k < 0)
return 0;
return (k * (k + 1)) / 2;
}
struct FenwickTree {
int N;
vector<int> tree;
void init(int n) {
N = n;
tree.assign(n + 1, 0);
}
void update(int idx, int val) {
while (idx <= N) {
tree[idx] += val;
idx += idx & -idx;
}
}
void updateMax(int idx, int val) {
while (idx <= N) {
tree[idx] = max(tree[idx], val);
idx += idx & -idx;
}
}
int pref(int idx) {
int ans = 0;
while (idx > 0) {
ans += tree[idx];
idx -= idx & -idx;
}
return ans;
}
int rsum(int l, int r) { return pref(r) - pref(l - 1); }
int prefMax(int idx) {
int ans = -2e9;
while (idx > 0) {
ans = max(ans, tree[idx]);
idx -= idx & -idx;
}
return ans;
}
};
//~ const int MAXN = 1e6+10;
//~ std::vector <int> prime;
//~ bool is_composite[MAXN];
//~ void sieve (int n) {
//~ std::fill (is_composite, is_composite + n, false);
//~ for (int i = 2; i < n; ++i) {
//~ if (!is_composite[i]) prime.push_back (i);
//~ for (int j = 0; j < (int)prime.size () && i * prime[j] < n; ++j) {
//~ is_composite[i * prime[j]] = true;
//~ if (i % prime[j] == 0) break;
//~ }
//~ }
//~ }
const int INF = 1e9 + 10;
int main() {
fast;
ll t;
t = 1;
//~ cin>>t;
while (t--) {
int n;
cin >> n;
vector<int> dp(3);
for (int day = 0; day < n; day++) {
vector<int> c(3);
vector<int> new_dp(3, 0);
for (int &it : c) {
cin >> it;
}
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (i != j) {
new_dp[j] = max(new_dp[j], dp[i] + c[j]);
}
}
}
dp = new_dp;
}
cout << max({dp[0], dp[2], dp[1]});
}
return 0;
}
| [
"call.arguments.change",
"assignment.value.change",
"identifier.change"
] | 962,892 | 962,901 | u630231163 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int a[100000][3];
int f[100000][3];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++)
cin >> a[i][j];
}
f[0][0] = a[0][0];
f[0][1] = a[0][1];
f[0][2] = a[0][2];
for (int i = 1; i < n; i++) {
f[i][0] = a[i][0] + max(f[i - 1][1], f[i - 1][2]);
f[i][1] = a[i][1] + max(f[i - 1][2], f[i - 1][1]);
f[i][2] = a[i][2] + max(f[i - 1][1], f[i - 1][0]);
}
cout << max(f[n - 1][0], max(f[n - 1][1], f[n - 1][2]));
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int a[100000][3];
int f[100000][3];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++)
cin >> a[i][j];
}
f[0][0] = a[0][0];
f[0][1] = a[0][1];
f[0][2] = a[0][2];
for (int i = 1; i < n; i++) {
f[i][0] = a[i][0] + max(f[i - 1][1], f[i - 1][2]);
f[i][1] = a[i][1] + max(f[i - 1][2], f[i - 1][0]);
f[i][2] = a[i][2] + max(f[i - 1][1], f[i - 1][0]);
}
cout << max(f[n - 1][0], max(f[n - 1][1], f[n - 1][2]));
return 0;
} | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 962,905 | 962,906 | u650458605 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int solve(int a[], int b[], int c[], int n) {
int dp[n][3];
dp[0][0] = a[0];
dp[0][1] = b[0];
dp[0][2] = c[2];
for (int i = 1; i < n; i++) {
dp[i][0] = a[i] + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = b[i] + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = c[i] + max(dp[i - 1][1], dp[i - 1][0]);
}
return max({dp[n - 1][0], dp[n - 1][1], dp[n - 1][2]});
}
int main() {
int n;
cin >> n;
int a[n], b[n], c[n];
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i] >> c[i];
}
cout << solve(a, b, c, n) << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int solve(int a[], int b[], int c[], int n) {
int dp[n][3];
dp[0][0] = a[0];
dp[0][1] = b[0];
dp[0][2] = c[0];
for (int i = 1; i < n; i++) {
dp[i][0] = a[i] + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = b[i] + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = c[i] + max(dp[i - 1][1], dp[i - 1][0]);
}
return max({dp[n - 1][0], dp[n - 1][1], dp[n - 1][2]});
}
int main() {
int n;
cin >> n;
int a[n], b[n], c[n];
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i] >> c[i];
}
cout << solve(a, b, c, n) << endl;
} | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change"
] | 962,910 | 962,911 | u566869069 | cpp |
p03162 | #include <bits/stdc++.h>
#define rep(i, f, n) for (ll i = (f); (i) < (n); i++)
#define repe(i, f, n) for (ll i = (f); (i) <= (n); i++)
using namespace std;
using ll = long long;
ll INF = 1e+18;
int iINF = 1e9;
int MAXI = 1e8 + 1;
using vec = vector<int>;
int main() {
int N;
cin >> N;
vector<vector<int>> arr(N);
rep(i, 0, N) {
int a, b, c;
cin >> a >> b >> c;
arr[i].push_back(a);
arr[i].push_back(b);
arr[i].push_back(c);
}
vector<vector<int>> dp(N, vec(3, 0));
dp[0][0] = arr[0][0];
dp[0][1] = arr[0][1];
dp[0][2] = arr[0][2];
rep(i, 0, N - 1) {
rep(j, 0, 3) {
rep(k, 0, 3) {
if (j == k)
continue;
if (dp[j + 1][k] < dp[i][j] + arr[i + 1][k])
dp[i + 1][k] = dp[i][j] + arr[i + 1][k];
}
}
}
int ans = 0;
rep(i, 0, 3) {
if (dp[N - 1][i] > ans)
ans = dp[N - 1][i];
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define rep(i, f, n) for (ll i = (f); (i) < (n); i++)
#define repe(i, f, n) for (ll i = (f); (i) <= (n); i++)
using namespace std;
using ll = long long;
ll INF = 1e+18;
int iINF = 1e9;
int MAXI = 1e8 + 1;
using vec = vector<int>;
int main() {
int N;
cin >> N;
vector<vector<int>> arr(N);
rep(i, 0, N) {
int a, b, c;
cin >> a >> b >> c;
arr[i].push_back(a);
arr[i].push_back(b);
arr[i].push_back(c);
}
vector<vector<int>> dp(N, vec(3, 0));
dp[0][0] = arr[0][0];
dp[0][1] = arr[0][1];
dp[0][2] = arr[0][2];
rep(i, 0, N - 1) {
rep(j, 0, 3) {
rep(k, 0, 3) {
if (j == k)
continue;
if (dp[i + 1][k] < dp[i][j] + arr[i + 1][k])
dp[i + 1][k] = dp[i][j] + arr[i + 1][k];
}
}
}
int ans = 0;
rep(i, 0, 3) {
if (dp[N - 1][i] > ans)
ans = dp[N - 1][i];
}
cout << ans << endl;
} | [
"identifier.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 962,912 | 962,913 | u873269440 | cpp |
p03162 | #include <iostream>
using namespace std;
long long n, f[4][100004], a[4][100005];
int main() {
cin >> n;
for (long long i = 1; i <= n; ++i) {
cin >> a[i][1] >> a[i][2] >> a[i][3];
}
f[1][1] = a[1][1];
f[1][2] = a[1][2];
f[1][3] = a[1][3];
for (long long i = 2; i <= n; ++i) {
for (long long j = 1; j <= 3; ++j) {
if (j == 1) {
f[i][j] = max(f[i - 1][2], f[i - 1][3]) + a[i][j];
} else if (j == 2) {
f[i][j] = max(f[i - 1][1], f[i - 1][3]) + a[i][j];
} else if (j == 3) {
f[i][j] = max(f[i - 1][1], f[i - 1][2]) + a[i][j];
}
}
}
cout << max(f[n][1], max(f[n][2], f[n][3]));
return 0;
} | #include <iostream>
using namespace std;
long long n, f[100005][4], a[100005][4];
int main() {
cin >> n;
for (long long i = 1; i <= n; ++i) {
cin >> a[i][1] >> a[i][2] >> a[i][3];
}
f[1][1] = a[1][1];
f[1][2] = a[1][2];
f[1][3] = a[1][3];
for (long long i = 2; i <= n; ++i) {
for (long long j = 1; j <= 3; ++j) {
if (j == 1) {
f[i][j] = max(f[i - 1][2], f[i - 1][3]) + a[i][j];
} else if (j == 2) {
f[i][j] = max(f[i - 1][1], f[i - 1][3]) + a[i][j];
} else if (j == 3) {
f[i][j] = max(f[i - 1][1], f[i - 1][2]) + a[i][j];
}
}
}
cout << max(f[n][1], max(f[n][2], f[n][3]));
return 0;
} | [
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 962,918 | 962,919 | u519309774 | cpp |
p03162 | #include <bits/stdc++.h>
#define int long long
using namespace std;
int arr[10010][10010];
int dp[10010][10010];
signed main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i][0] >> arr[i][1] >> arr[i][2];
}
for (int i = 0; i < 3; i++) {
dp[0][i] = arr[0][i];
}
for (int i = 1; i < n; i++) {
dp[i][0] = max(dp[i - 1][1] + arr[i][0], dp[i - 1][2] + arr[i][0]);
dp[i][1] = max(dp[i - 1][0] + arr[i][1], dp[i - 1][2] + arr[i][1]);
dp[i][2] = max(dp[i - 1][0] + arr[i][2], dp[i - 1][1] + arr[i][2]);
}
cout << max(max(dp[n - 1][0], dp[n - 1][1]), dp[n - 1][2]) << "\n";
} | #include <bits/stdc++.h>
#define int long long
using namespace std;
int arr[100100][4];
int dp[100100][4];
signed main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i][0] >> arr[i][1] >> arr[i][2];
}
for (int i = 0; i < 3; i++) {
dp[0][i] = arr[0][i];
}
for (int i = 1; i < n; i++) {
dp[i][0] = max(dp[i - 1][1] + arr[i][0], dp[i - 1][2] + arr[i][0]);
dp[i][1] = max(dp[i - 1][0] + arr[i][1], dp[i - 1][2] + arr[i][1]);
dp[i][2] = max(dp[i - 1][0] + arr[i][2], dp[i - 1][1] + arr[i][2]);
}
cout << max(max(dp[n - 1][0], dp[n - 1][1]), dp[n - 1][2]) << "\n";
} | [
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 962,920 | 962,921 | u035075095 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int n;
int dp[100001][4];
int point[100001][4];
int maxP(int i, int last) {
if (i == n)
return 0;
int ret = INT_MIN;
if (dp[i][last] != -1)
return dp[i][last];
for (int j = 1; j <= 3; j++) {
if (j != last) {
ret = max(ret, point[i][j] + maxP(i + 1, j));
}
return dp[i][last] = ret;
}
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> point[i][1] >> point[i][2] >> point[i][3];
}
memset(dp, -1, sizeof(dp));
cout << maxP(0, 0);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int n;
int dp[100001][4];
int point[100001][4];
int maxP(int i, int last) {
if (i == n)
return 0;
int ret = INT_MIN;
if (dp[i][last] != -1)
return dp[i][last];
for (int j = 1; j <= 3; j++) {
if (j != last) {
ret = max(ret, point[i][j] + maxP(i + 1, j));
}
}
return dp[i][last] = ret;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> point[i][1] >> point[i][2] >> point[i][3];
}
memset(dp, -1, sizeof(dp));
cout << maxP(0, 0);
return 0;
}
| [] | 962,922 | 962,923 | u061594873 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int dp[100005][4];
int main() {
int t;
cin >> t;
int a, b, c;
for (int i = 0; i < t; i++) {
cin >> a >> b >> c;
if (i == 0) {
dp[i][0] = a;
dp[i][1] = b;
dp[i][2] = c;
} else {
dp[i][0] = max(dp[i - 1][1] + a, dp[i - 1][2] + a);
dp[i][1] = max(dp[i - 1][0] + b, dp[i - 1][2] + b);
dp[i][2] = max(dp[i - 1][1] + c, dp[i - 1][2] + c);
}
}
int ans = max(dp[t - 1][0], max(dp[t - 1][1], dp[t - 1][2]));
cout << ans;
}
| #include <bits/stdc++.h>
using namespace std;
int dp[100005][4];
int main() {
int t;
cin >> t;
int a, b, c;
for (int i = 0; i < t; i++) {
cin >> a >> b >> c;
if (i == 0) {
dp[i][0] = a;
dp[i][1] = b;
dp[i][2] = c;
} else {
dp[i][0] = max(dp[i - 1][1] + a, dp[i - 1][2] + a);
dp[i][1] = max(dp[i - 1][0] + b, dp[i - 1][2] + b);
dp[i][2] = max(dp[i - 1][1] + c, dp[i - 1][0] + c);
}
}
int ans = max(dp[t - 1][0], max(dp[t - 1][1], dp[t - 1][2]));
cout << ans;
}
| [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 962,924 | 962,925 | u704227127 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 5;
void a() {
ios::sync_with_stdio(0);
cin.tie(0);
}
int main() {
a();
int n;
cin >> n;
vector<int> dp(3);
for (int i = 0; i < n; i++) {
vector<int> aux(3, 0), c(3);
for (int j = 0; j < 3; j++)
cin >> c[j];
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
if (j != k) {
aux[k] = max(aux[k], aux[j] + c[k]);
}
}
}
dp = aux;
}
cout << max({dp[0], dp[1], dp[2]});
}
| #include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 5;
void a() {
ios::sync_with_stdio(0);
cin.tie(0);
}
int main() {
a();
int n;
cin >> n;
vector<int> dp(3);
for (int i = 0; i < n; i++) {
vector<int> aux(3, 0), c(3);
for (int j = 0; j < 3; j++)
cin >> c[j];
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
if (j != k) {
aux[k] = max(aux[k], dp[j] + c[k]);
}
}
}
dp = aux;
}
cout << max({dp[0], dp[1], dp[2]});
} | [
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 962,926 | 962,927 | u068387844 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n], b[n], c[n];
for (int i = 0; i < n; i++)
cin >> a[i] >> b[i] >> c[i];
int dp[n][3];
dp[0][0] = a[0];
dp[0][1] = b[0];
dp[0][2] = c[0];
for (int i = 1; i < n; i++) {
dp[i][0] = a[i] + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = a[i] + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = a[i] + max(dp[i - 1][1], dp[i - 1][0]);
}
cout << max(dp[n - 1][0], max(dp[n - 1][2], dp[n - 1][1]));
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n], b[n], c[n];
for (int i = 0; i < n; i++)
cin >> a[i] >> b[i] >> c[i];
int dp[n][3];
dp[0][0] = a[0];
dp[0][1] = b[0];
dp[0][2] = c[0];
for (int i = 1; i < n; i++) {
dp[i][0] = a[i] + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = b[i] + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = c[i] + max(dp[i - 1][1], dp[i - 1][0]);
}
cout << max(dp[n - 1][0], max(dp[n - 1][2], dp[n - 1][1]));
return 0;
} | [
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 962,928 | 962,929 | u847935562 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n], b[n], c[n];
for (int i = 0; i < n; i++)
cin >> a[i] >> b[i] >> c[i];
int dp[n][3];
dp[0][0] = a[0];
dp[0][1] = b[0];
dp[0][2] = c[0];
for (int i = 1; i < n; i++) {
dp[i][0] = a[i] + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = a[i] + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = a[i] + max(dp[i - 1][1], dp[i - 1][0]);
}
cout << min(dp[n - 1][0], min(dp[n - 1][2], dp[n - 1][1]));
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n], b[n], c[n];
for (int i = 0; i < n; i++)
cin >> a[i] >> b[i] >> c[i];
int dp[n][3];
dp[0][0] = a[0];
dp[0][1] = b[0];
dp[0][2] = c[0];
for (int i = 1; i < n; i++) {
dp[i][0] = a[i] + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = b[i] + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = c[i] + max(dp[i - 1][1], dp[i - 1][0]);
}
cout << max(dp[n - 1][0], max(dp[n - 1][2], dp[n - 1][1]));
return 0;
} | [
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change",
"misc.opposites",
"call.function.change",
"io.output.change"
] | 962,930 | 962,929 | u847935562 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n], b[n], c[n];
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i] >> c[i];
}
int dp[n][3];
dp[0][0] = a[0];
dp[0][1] = b[0];
dp[0][2] = c[0];
for (int i = 1; i < n; i++) {
dp[i][0] = a[i] + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = b[i] + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][0] = c[i] + max(dp[i - 1][0], dp[i - 1][1]);
}
cout << max({dp[n - 1][0], dp[n - 1][1], dp[n - 1][2]});
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n], b[n], c[n];
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i] >> c[i];
}
int dp[n][3];
dp[0][0] = a[0];
dp[0][1] = b[0];
dp[0][2] = c[0];
for (int i = 1; i < n; i++) {
dp[i][0] = a[i] + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = b[i] + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = c[i] + max(dp[i - 1][0], dp[i - 1][1]);
}
cout << max({dp[n - 1][0], dp[n - 1][1], dp[n - 1][2]});
return 0;
} | [
"literal.number.change",
"assignment.variable.change",
"variable_access.subscript.index.change"
] | 962,934 | 962,935 | u162798110 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod = 1e9 + 7;
const long long INF = 1e15;
int main() {
int n;
cin >> n;
int dp[3][n];
for (int i = 0; i < 3; i++) {
for (int j = 0; j < n; j++) {
dp[i][j] = 0;
}
int a;
cin >> a;
dp[i][0] = a;
}
for (int i = 0; i < n - 1; i++) {
int a[3];
for (int j = 0; j < 3; j++)
cin >> a[j];
dp[0][i + 1] = max(dp[0][i + 1], dp[1][i] + a[0]);
dp[0][i + 1] = max(dp[0][i + 1], dp[2][i] + a[0]);
dp[1][i + 1] = max(dp[0][i + 1], dp[0][i] + a[1]);
dp[1][i + 1] = max(dp[0][i + 1], dp[2][i] + a[1]);
dp[2][i + 1] = max(dp[0][i + 1], dp[0][i] + a[2]);
dp[2][i + 1] = max(dp[0][i + 1], dp[1][i] + a[2]);
}
int ans = 0;
for (int i = 0; i < 3; i++) {
ans = max(ans, dp[i][n - 1]);
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod = 1e9 + 7;
const long long INF = 1e15;
int main() {
int n;
cin >> n;
int dp[3][n];
for (int i = 0; i < 3; i++) {
for (int j = 0; j < n; j++) {
dp[i][j] = 0;
}
int a;
cin >> a;
dp[i][0] = a;
}
for (int i = 0; i < n - 1; i++) {
int a[3];
for (int j = 0; j < 3; j++)
cin >> a[j];
dp[0][i + 1] = max(dp[0][i + 1], dp[1][i] + a[0]);
dp[0][i + 1] = max(dp[0][i + 1], dp[2][i] + a[0]);
dp[1][i + 1] = max(dp[1][i + 1], dp[0][i] + a[1]);
dp[1][i + 1] = max(dp[1][i + 1], dp[2][i] + a[1]);
dp[2][i + 1] = max(dp[2][i + 1], dp[0][i] + a[2]);
dp[2][i + 1] = max(dp[2][i + 1], dp[1][i] + a[2]);
}
int ans = 0;
for (int i = 0; i < 3; i++) {
ans = max(ans, dp[i][n - 1]);
}
cout << ans << endl;
return 0;
} | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change"
] | 962,936 | 962,937 | u191484928 | cpp |
p03162 | #include <bits/stdc++.h>
#include <sstream>
using namespace std;
#define pr(x) cout << x
#define prs cout << " "
#define prn cout << "\n"
#define sc(x) cin >> x
#define ll long long int
int arr[1000005][3];
int dp[1000005][3];
int n;
int main() {
ios ::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
for (int i9 = 1; i9 <= t; i9++) {
cin >> n;
int res = 0;
// cout<<"Cae #"<<i9<<": "<<res<<endl;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++)
cin >> arr[i][j];
}
memset(dp, 0, sizeof(dp));
dp[0][0] = arr[0][0];
dp[0][1] = arr[0][1];
dp[0][2] = arr[0][2];
for (int i = 1; i < n; i++) {
dp[i][0] = arr[i][0] + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = arr[i][1] + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = arr[i][2] + max(dp[i - 1][0], dp[i - 1][1]);
}
res = INT_MIN;
for (int i = 0; i < 3; i++)
res = max(res, dp[n - 1][i]);
cout << res << endl;
}
} | #include <bits/stdc++.h>
#include <sstream>
using namespace std;
#define pr(x) cout << x
#define prs cout << " "
#define prn cout << "\n"
#define sc(x) cin >> x
#define ll long long int
int arr[1000005][3];
int dp[1000005][3];
int n;
int main() {
ios ::sync_with_stdio(false);
cin.tie(0);
int t = 1;
// cin >> t;
for (int i9 = 1; i9 <= t; i9++) {
cin >> n;
int res = 0;
// cout<<"Cae #"<<i9<<": "<<res<<endl;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++)
cin >> arr[i][j];
}
memset(dp, 0, sizeof(dp));
dp[0][0] = arr[0][0];
dp[0][1] = arr[0][1];
dp[0][2] = arr[0][2];
for (int i = 1; i < n; i++) {
dp[i][0] = arr[i][0] + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = arr[i][1] + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = arr[i][2] + max(dp[i - 1][0], dp[i - 1][1]);
}
res = INT_MIN;
for (int i = 0; i < 3; i++)
res = max(res, dp[n - 1][i]);
cout << res << endl;
}
} | [
"expression.operation.binary.remove"
] | 962,940 | 962,941 | u833947449 | cpp |
p03162 | // THIS IS MY NINJA WAY
#include <algorithm>
#include <bits/stdc++.h>
#include <ctime>
#include <vector>
#define str string
#define dbl double
#define ll long long
#define vl vector<ll>
#define vs vector<str>
#define pll pair<ll, ll>
#define vll vector<pll>
#define sl set<ll>
#define pb push_back
#define mp make_pair
#define ub upper_bound
#define lb lower_bound
#define ff first
#define ss second
#define fast \
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0); \
srand(time(NULL));
#define fr(i, a, b) for (long long i = a; i < b; i++)
#define nfr(i, a, b) for (long long i = a; i <= b; i++)
#define psl pair<str, ll>
#define pls pair<ll, str>
#define pss pair<str, str>
#define ALL(a) a.begin(), a.end()
#define stl stack<ll>
#define coml complex<ll>
#define INF 0x3f3f3f3f3f3f3f3f
#define max3(a, b, c) max(a, max(b, c))
#define min3(a, b, c) min(a, min(b, c))
const ll MOD = 1e9 + 7;
using namespace std;
int main() {
fast
/*#ifndef ONLINE_JUDGE
freopen("input.txt", "r" , stdin);
freopen("output.txt", "w" , stdout);
#endif*/
ll n;
cin >> n;
vector<vl> v(n, vl(3));
fr(i, 0, n) { fr(j, 0, 3) cin >> v[i][j]; }
vector<vl> dp(n, vl(3, 0));
dp[0] = v[0];
fr(i, 0, n) {
fr(j, 0, 3) {
fr(k, 0, 3) {
if (j != k)
dp[i][k] = max(dp[i][k], dp[i - 1][j] + v[i][k]);
}
}
}
cout << *max_element(ALL(dp[n - 1]));
return 0;
} | // THIS IS MY NINJA WAY
#include <algorithm>
#include <bits/stdc++.h>
#include <ctime>
#include <vector>
#define str string
#define dbl double
#define ll long long
#define vl vector<ll>
#define vs vector<str>
#define pll pair<ll, ll>
#define vll vector<pll>
#define sl set<ll>
#define pb push_back
#define mp make_pair
#define ub upper_bound
#define lb lower_bound
#define ff first
#define ss second
#define fast \
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0); \
srand(time(NULL));
#define fr(i, a, b) for (long long i = a; i < b; i++)
#define nfr(i, a, b) for (long long i = a; i <= b; i++)
#define psl pair<str, ll>
#define pls pair<ll, str>
#define pss pair<str, str>
#define ALL(a) a.begin(), a.end()
#define stl stack<ll>
#define coml complex<ll>
#define INF 0x3f3f3f3f3f3f3f3f
#define max3(a, b, c) max(a, max(b, c))
#define min3(a, b, c) min(a, min(b, c))
const ll MOD = 1e9 + 7;
using namespace std;
int main() {
fast
/*#ifndef ONLINE_JUDGE
freopen("input.txt", "r" , stdin);
freopen("output.txt", "w" , stdout);
#endif*/
ll n;
cin >> n;
vector<vl> v(n, vl(3));
fr(i, 0, n) { fr(j, 0, 3) cin >> v[i][j]; }
vector<vl> dp(n, vl(3, 0));
dp[0] = v[0];
fr(i, 1, n) {
fr(j, 0, 3) {
fr(k, 0, 3) {
if (j != k)
dp[i][k] = max(dp[i][k], dp[i - 1][j] + v[i][k]);
}
}
}
cout << *max_element(ALL(dp[n - 1]));
return 0;
} | [
"literal.number.change",
"call.arguments.change"
] | 962,946 | 962,947 | u430369139 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
const int maxN = 100100;
int grid[maxN][4];
int input[maxN][4];
int n;
int solve(int i, int type) {
if (i > n) {
return 0;
}
if (grid[i][type] != -1) {
return grid[i][type];
}
int res = 0;
for (int j = 1; j <= 3; j++) {
if (j != type) {
res = max(res, input[i][j] + solve(i + 1, j));
}
}
return grid[i][type] = res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
memset(grid, -1, sizeof(grid));
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> input[i][1] >> input[i][2] >> input[i][3];
}
cout << solve(1, 1) << "\n";
}
| #include <bits/stdc++.h>
using namespace std;
const int maxN = 100100;
int grid[maxN][4];
int input[maxN][4];
int n;
int solve(int i, int type) {
if (i > n) {
return 0;
}
if (grid[i][type] != -1) {
return grid[i][type];
}
int res = 0;
for (int j = 1; j <= 3; j++) {
if (j != type) {
res = max(res, input[i][j] + solve(i + 1, j));
}
}
return grid[i][type] = res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
memset(grid, -1, sizeof(grid));
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> input[i][1] >> input[i][2] >> input[i][3];
}
cout << solve(1, 0) << "\n";
}
| [
"literal.number.change",
"io.output.change"
] | 962,956 | 962,957 | u763460982 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
long long arr[10001][10001] = {0};
int main() {
long long n;
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
int a;
cin >> a;
arr[i][j] = a;
}
}
long long dp[10001][3];
memset(dp, 0, sizeof dp);
dp[0][0] = arr[0][0];
dp[0][1] = arr[0][1];
dp[0][2] = arr[0][2];
for (int i = 1; i < n; i++) {
for (int j = 0; j < 3; j++) {
if (j == 0) {
dp[i][j] = arr[i][j] + max(dp[i - 1][1], dp[i - 1][2]);
}
if (j == 1) {
dp[i][j] = arr[i][j] + max(dp[i - 1][0], dp[i - 1][2]);
}
if (j == 2) {
dp[i][j] = arr[i][j] + max(dp[i - 1][0], dp[i - 1][1]);
}
}
}
long long ans = max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2]));
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
long long arr[100001][3] = {0};
int main() {
long long n;
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
int a;
cin >> a;
arr[i][j] = a;
}
}
long long dp[100001][3];
memset(dp, 0, sizeof dp);
dp[0][0] = arr[0][0];
dp[0][1] = arr[0][1];
dp[0][2] = arr[0][2];
for (int i = 1; i < n; i++) {
for (int j = 0; j < 3; j++) {
if (j == 0) {
dp[i][j] = arr[i][j] + max(dp[i - 1][1], dp[i - 1][2]);
}
if (j == 1) {
dp[i][j] = arr[i][j] + max(dp[i - 1][0], dp[i - 1][2]);
}
if (j == 2) {
dp[i][j] = arr[i][j] + max(dp[i - 1][0], dp[i - 1][1]);
}
}
}
long long ans = max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2]));
cout << ans << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 962,821 | 962,822 | u004244461 | cpp |
p03162 | #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int a[100000][100000];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> a[i][j];
}
}
int dp[100000][100000];
dp[0][0] = a[0][0];
dp[0][1] = a[0][1];
dp[0][2] = a[0][2];
for (int i = 1; i < n; i++) {
for (int j = 0; j <= 2; j++) {
if (j == 0) {
dp[i][j] = a[i][j] + max(dp[i - 1][j + 1], dp[i - 1][j + 2]);
} else if (j == 1) {
dp[i][j] = a[i][j] + max(dp[i - 1][j - 1], dp[i - 1][j + 1]);
} else {
dp[i][j] = a[i][j] + max(dp[i - 1][j - 1], dp[i - 1][j - 2]);
}
}
}
int y = max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2]));
cout << y;
}
| #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int a[100000][4];
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
cin >> a[i][j];
}
}
int dp[100000][4];
dp[0][0] = a[0][0];
dp[0][1] = a[0][1];
dp[0][2] = a[0][2];
for (int i = 1; i < n; i++) {
for (int j = 0; j <= 2; j++) {
if (j == 0) {
dp[i][j] = a[i][j] + max(dp[i - 1][j + 1], dp[i - 1][j + 2]);
} else if (j == 1) {
dp[i][j] = a[i][j] + max(dp[i - 1][j - 1], dp[i - 1][j + 1]);
} else {
dp[i][j] = a[i][j] + max(dp[i - 1][j - 1], dp[i - 1][j - 2]);
}
}
}
int y = max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2]));
cout << y;
} | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 962,827 | 962,826 | u193104527 | cpp |
p03162 | #include <algorithm>
#include <iostream>
using namespace std;
int n, arr[100005][3], dp[100005][3];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
cin >> arr[i][j];
}
}
dp[0][0] = arr[0][0];
dp[0][1] = arr[0][2];
dp[0][2] = arr[0][3];
for (int i = 1; i < n; i++) {
dp[i][0] = max(dp[i - 1][1] + arr[i][0], dp[i - 1][2] + arr[i][0]);
dp[i][1] = max(dp[i - 1][0] + arr[i][1], dp[i - 1][2] + arr[i][1]);
dp[i][2] = max(dp[i - 1][1] + arr[i][2], dp[i - 1][0] + arr[i][2]);
}
cout << max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2]));
return 0;
} | #include <algorithm>
#include <iostream>
using namespace std;
int n, arr[100005][3], dp[100005][3];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
cin >> arr[i][j];
}
}
dp[0][0] = arr[0][0];
dp[0][1] = arr[0][1];
dp[0][2] = arr[0][2];
for (int i = 1; i < n; i++) {
dp[i][0] = max(dp[i - 1][1] + arr[i][0], dp[i - 1][2] + arr[i][0]);
dp[i][1] = max(dp[i - 1][0] + arr[i][1], dp[i - 1][2] + arr[i][1]);
dp[i][2] = max(dp[i - 1][1] + arr[i][2], dp[i - 1][0] + arr[i][2]);
}
cout << max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2]));
return 0;
} | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change"
] | 962,828 | 962,829 | u193834181 | cpp |
p03162 | #include <bits/stdc++.h>
#define ll long long
#define dbl double
#define forn(i, n, k) for (int i = 0; i < n; i = i + k)
#define forpn(p, n, k) for (int i = p; i < n; i += k)
#define for0(i, n) for (int i = 0; i < n; i++)
#define for1(i, n) for (int i = 1; i <= n; i++)
#define all(v) v.begin(), v.end()
using namespace std;
int no_of_bits(long long n) {
int count = 0;
while (n > 0) {
n = n >> 1;
count++;
}
return count;
}
long long gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
bool isPrime(int n) {
if (n == 1) {
return false;
}
int i = 2;
while (i * i <= n) {
if (n % i == 0) {
return false;
}
i += 1;
}
return true;
}
int main() {
ios::sync_with_stdio(0);
int t;
// cin>>t;
t = 1;
cin.tie(0);
cout.tie(0);
while (t--) {
int n;
cin >> n;
int a[n][3];
for0(i, n) { for0(j, 3) cin >> a[i][j]; }
int dp[n + 1][3];
memset(dp, 0, sizeof(dp));
for (int i = 0; i < n; i++) {
for0(j, 3) {
for0(k, 3) {
if (j == k)
continue;
else {
dp[i + 1][k] = max(dp[i + 1][k], dp[i][j] + a[i][k]);
}
}
}
}
cout << max(dp[n][0], min(dp[n][1], dp[n][2])) << endl;
}
return 0;
}
| #include <bits/stdc++.h>
#define ll long long
#define dbl double
#define forn(i, n, k) for (int i = 0; i < n; i = i + k)
#define forpn(p, n, k) for (int i = p; i < n; i += k)
#define for0(i, n) for (int i = 0; i < n; i++)
#define for1(i, n) for (int i = 1; i <= n; i++)
#define all(v) v.begin(), v.end()
using namespace std;
int no_of_bits(long long n) {
int count = 0;
while (n > 0) {
n = n >> 1;
count++;
}
return count;
}
long long gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
bool isPrime(int n) {
if (n == 1) {
return false;
}
int i = 2;
while (i * i <= n) {
if (n % i == 0) {
return false;
}
i += 1;
}
return true;
}
int main() {
ios::sync_with_stdio(0);
int t;
// cin>>t;
t = 1;
cin.tie(0);
cout.tie(0);
while (t--) {
int n;
cin >> n;
int a[n][3];
for0(i, n) { for0(j, 3) cin >> a[i][j]; }
int dp[n + 1][3];
memset(dp, 0, sizeof(dp));
for (int i = 0; i < n; i++) {
for0(j, 3) {
for0(k, 3) {
if (j == k)
continue;
else {
dp[i + 1][k] = max(dp[i + 1][k], dp[i][j] + a[i][k]);
}
}
}
}
cout << max(dp[n][0], max(dp[n][1], dp[n][2])) << endl;
}
return 0;
}
| [
"misc.opposites",
"identifier.change",
"call.function.change",
"io.output.change"
] | 962,830 | 962,831 | u883528203 | cpp |
p03162 | #include <bits/stdc++.h>
#define ll long long
#define dbl double
#define forn(i, n, k) for (int i = 0; i < n; i = i + k)
#define forpn(p, n, k) for (int i = p; i < n; i += k)
#define for0(i, n) for (int i = 0; i < n; i++)
#define for1(i, n) for (int i = 1; i <= n; i++)
#define all(v) v.begin(), v.end()
using namespace std;
int no_of_bits(long long n) {
int count = 0;
while (n > 0) {
n = n >> 1;
count++;
}
return count;
}
long long gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
bool isPrime(int n) {
if (n == 1) {
return false;
}
int i = 2;
while (i * i <= n) {
if (n % i == 0) {
return false;
}
i += 1;
}
return true;
}
int main() {
ios::sync_with_stdio(0);
int t;
// cin>>t;
t = 1;
cin.tie(0);
cout.tie(0);
while (t--) {
int n;
cin >> n;
int a[n][3];
for0(i, n) { for0(j, 3) cin >> a[i][j]; }
int dp[n + 1][3];
memset(dp, 0, sizeof(dp));
for (int i = 0; i < n; i++) {
for0(j, 3) {
for0(k, 3) {
if (j == k)
continue;
else {
dp[i + 1][j] = max(dp[i + 1][j], dp[i][k] + a[i][j]);
}
}
}
}
cout << max(dp[n][0], min(dp[n][1], dp[n][2])) << endl;
}
return 0;
}
| #include <bits/stdc++.h>
#define ll long long
#define dbl double
#define forn(i, n, k) for (int i = 0; i < n; i = i + k)
#define forpn(p, n, k) for (int i = p; i < n; i += k)
#define for0(i, n) for (int i = 0; i < n; i++)
#define for1(i, n) for (int i = 1; i <= n; i++)
#define all(v) v.begin(), v.end()
using namespace std;
int no_of_bits(long long n) {
int count = 0;
while (n > 0) {
n = n >> 1;
count++;
}
return count;
}
long long gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
bool isPrime(int n) {
if (n == 1) {
return false;
}
int i = 2;
while (i * i <= n) {
if (n % i == 0) {
return false;
}
i += 1;
}
return true;
}
int main() {
ios::sync_with_stdio(0);
int t;
// cin>>t;
t = 1;
cin.tie(0);
cout.tie(0);
while (t--) {
int n;
cin >> n;
int a[n][3];
for0(i, n) { for0(j, 3) cin >> a[i][j]; }
int dp[n + 1][3];
memset(dp, 0, sizeof(dp));
for (int i = 0; i < n; i++) {
for0(j, 3) {
for0(k, 3) {
if (j == k)
continue;
else {
dp[i + 1][k] = max(dp[i + 1][k], dp[i][j] + a[i][k]);
}
}
}
}
cout << max(dp[n][0], max(dp[n][1], dp[n][2])) << endl;
}
return 0;
}
| [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change",
"misc.opposites",
"call.function.change",
"io.output.change"
] | 962,832 | 962,831 | u883528203 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int dp[n][3];
int a, b, c;
for (int i = 0; i < n; i++) {
cin >> a >> b >> c;
if (i == 0) {
dp[i][0] = a;
dp[i][1] = b;
dp[i][2] = c;
} else {
dp[i][0] = a + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = b + max(dp[i - 1][0], dp[i - 1][1]);
dp[i][2] = c + max(dp[i - 1][0], dp[i - 1][2]);
}
}
int ans = max({dp[n - 1][0], dp[n - 1][1], dp[n - 1][2]});
cout << ans;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int dp[n][3];
int a, b, c;
for (int i = 0; i < n; i++) {
cin >> a >> b >> c;
if (i == 0) {
dp[0][0] = a;
dp[0][1] = b;
dp[0][2] = c;
} else {
dp[i][0] = a + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = b + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = c + max(dp[i - 1][0], dp[i - 1][1]);
}
}
int ans = max({dp[n - 1][0], dp[n - 1][1], dp[n - 1][2]});
cout << ans;
}
| [
"assignment.variable.change",
"identifier.replace.remove",
"literal.replace.add",
"variable_access.subscript.index.change",
"literal.number.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 962,840 | 962,841 | u165182711 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define all(n) (n).begin(), (n).end()
#define fi first
#define se second
typedef pair<int, int> PII;
typedef long long ll;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
int a[100005][3];
memset(a, 0, sizeof(a));
for (int i = 1; i <= n; i++)
cin >> a[i][0] >> a[i][1] >> a[i][2];
int dp[100005][3];
memset(dp, 0, sizeof(dp));
dp[1][0] = a[1][0];
dp[1][1] = a[1][1];
dp[1][2] = a[1][2];
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
if (j == k)
continue;
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j] + a[i + 1][k]);
}
}
}
cout << max({dp[n][0], dp[n][1], dp[n][2]}) << "\n";
} | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define all(n) (n).begin(), (n).end()
#define fi first
#define se second
typedef pair<int, int> PII;
typedef long long ll;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
int a[100005][3];
memset(a, 0, sizeof(a));
for (int i = 1; i <= n; i++)
cin >> a[i][0] >> a[i][1] >> a[i][2];
int dp[100005][3];
memset(dp, 0, sizeof(dp));
dp[1][0] = a[1][0];
dp[1][1] = a[1][1];
dp[1][2] = a[1][2];
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
if (j == k)
continue;
dp[i + 1][k] = max(dp[i + 1][k], dp[i][j] + a[i + 1][k]);
}
}
}
cout << max({dp[n][0], dp[n][1], dp[n][2]}) << "\n";
} | [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change",
"assignment.value.change",
"call.arguments.change"
] | 962,850 | 962,851 | u560390257 | cpp |
p03162 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
int main() {
int n;
vector<vector<int>> a(n, vector<int>(3)), dp(n, vector<int>(3, INT_MIN));
for (int i = 0; i < n; i++)
for (int j = 0; j < 3; j++)
cin >> a[i][j];
dp[0][0] = a[0][0];
dp[0][1] = a[0][1];
dp[0][2] = a[0][2];
for (int i = 1; i < n; i++)
for (int j = 0; j < 3; j++)
for (int k = 0; k < 3; k++)
if (j != k)
dp[i][j] = max(dp[i][j], dp[i - 1][k] + a[i][j]);
cout << max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2]));
}
| #include <bits/stdc++.h>
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
vector<vector<int>> a(n, vector<int>(3)), dp(n, vector<int>(3, INT_MIN));
for (int i = 0; i < n; i++)
for (int j = 0; j < 3; j++)
cin >> a[i][j];
dp[0][0] = a[0][0];
dp[0][1] = a[0][1];
dp[0][2] = a[0][2];
for (int i = 1; i < n; i++)
for (int j = 0; j < 3; j++)
for (int k = 0; k < 3; k++)
if (j != k)
dp[i][j] = max(dp[i][j], dp[i - 1][k] + a[i][j]);
cout << max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2]));
}
| [] | 962,852 | 962,853 | u638369926 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define int long long
typedef pair<int, int> P;
int INF = 1e9 + 7;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int dp[100005][5] = {};
signed main() {
int N;
cin >> N;
int a, b, c;
cin >> a >> b >> c;
dp[0][0] = a;
dp[0][1] = b;
dp[0][2] = c;
for (int i = 1; i < N; i++) {
int a, b, c;
cin >> a >> b >> c;
dp[i][0] = max(dp[i - 1][1] + a, dp[i - 1][2] + a);
dp[i][1] = max(dp[i - 1][0] + b, dp[i - 1][2] + b);
dp[i][2] = max(dp[i - 1][0] + c, dp[i - 1][1] + c);
}
cout << max({dp[N - 1][0], dp[N - 1][0], dp[N - 1][2]}) << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
typedef pair<int, int> P;
int INF = 1e9 + 7;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int dp[100005][5] = {};
signed main() {
int N;
cin >> N;
int a, b, c;
cin >> a >> b >> c;
dp[0][0] = a;
dp[0][1] = b;
dp[0][2] = c;
for (int i = 1; i < N; i++) {
int a, b, c;
cin >> a >> b >> c;
dp[i][0] = max(dp[i - 1][1] + a, dp[i - 1][2] + a);
dp[i][1] = max(dp[i - 1][0] + b, dp[i - 1][2] + b);
dp[i][2] = max(dp[i - 1][0] + c, dp[i - 1][1] + c);
}
cout << max({dp[N - 1][0], dp[N - 1][1], dp[N - 1][2]}) << endl;
}
| [
"literal.number.change",
"variable_access.subscript.index.change",
"io.output.change"
] | 962,854 | 962,855 | u237390401 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define BOLT ios_base::sync_with_stdio(0)
#define newline cout << "\n"
#define eline cerr << "\n"
#define LL_MAX 9223372036854775807
#define LL_MIN -9223372036854775808
#define IN_FILE freopen("input.txt", "r", stdin)
#define OUT_FILE freopen("output.txt", "w", stdout)
long long arr[100000 + 2][3];
long long dp[100000 + 2][3];
int n;
// g++ -o contest contest.cpp
void USEFILE() {
IN_FILE;
OUT_FILE;
}
void reset() {
memset(arr, 0, sizeof arr);
memset(dp, -1, sizeof dp);
}
long long process(int i, int j) {
// cout << "Incoming: " << i << " " << j; newline;
if (i == n)
return 0;
if (dp[i][j] != -1)
return dp[i][j];
long long ans = 0;
for (int k = 0; k < 3; k++) {
if (k == j) {
continue;
}
// cout << "\tOutgoing: " << i << " " << j;
ans = max(ans, arr[i][k] + process(i + 1, k));
}
dp[i][j] = ans;
return ans;
}
void solve(int kase) {
reset();
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
cin >> arr[i][j];
}
}
cout << process(0, 0);
newline;
}
int main() {
BOLT;
// USEFILE();
int t, kase = 0;
// cin >> t;
// while(t--)
// solve(++kase);
solve(0);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define BOLT ios_base::sync_with_stdio(0)
#define newline cout << "\n"
#define eline cerr << "\n"
#define LL_MAX 9223372036854775807
#define LL_MIN -9223372036854775808
#define IN_FILE freopen("input.txt", "r", stdin)
#define OUT_FILE freopen("output.txt", "w", stdout)
long long arr[100000 + 2][3];
long long dp[100000 + 2][3];
int n;
// g++ -o contest contest.cpp
void USEFILE() {
IN_FILE;
OUT_FILE;
}
void reset() {
memset(arr, 0, sizeof arr);
memset(dp, -1, sizeof dp);
}
long long process(int i, int j) {
// cout << "Incoming: " << i << " " << j; newline;
if (i >= n)
return 0;
if (dp[i][j] != -1)
return dp[i][j];
long long ans = 0;
for (int k = 0; k < 3; k++) {
if (k == j && i != 0) {
continue;
}
// cout << "\tOutgoing: " << i << " " << j;newline;
ans = max(ans, arr[i][k] + process(i + 1, k));
}
dp[i][j] = ans;
return ans;
}
void solve(int kase) {
reset();
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
cin >> arr[i][j];
}
}
cout << process(0, 0);
newline;
}
int main() {
BOLT;
// USEFILE();
int t, kase = 0;
// cin >> t;
// while(t--)
// solve(++kase);
solve(0);
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 962,856 | 962,857 | u084217401 | cpp |
p03162 | #include <bits/stdc++.h>
#define int long long int
#define endl '\n'
#define pb push_back
#define mod 1000000007
#define db(i) cout << i << " ";
#define db1(i) cout << "(" << i << ")";
#define db2(i) cout << "[" << i << "]";
#define db3(i) cout << "{" << i << "}";
#define ff first
#define ss second
#define vv vector
#define pp pair
#define pi acos(-1);
#define printarr(a, n) \
cout << "["; \
for (int i = 0; i < n; i++) { \
db1(a[i]); \
} \
cout << "]";
#define inf LLONG_MAX
#define ninf LLONG_MIN
#define MAXN 100001
using namespace std;
//..................................................................................................//
vector<int> prime;
int fprime = 0;
void seiveprime(int n) {
fprime = 123;
bool pr[n + 1];
memset(pr, true, sizeof(pr));
for (int p = 2; p * p <= n; p++) {
if (pr[p] == true) {
for (int i = p * p; i <= n; i += p)
pr[i] = false;
}
}
for (int p = 2; p <= n; p++)
if (pr[p])
prime.pb(p);
}
//...................................................................................................//
vector<pp<int, int>> primefactors(int n) {
vector<pp<int, int>> v;
int co = 0;
while (n % 2 == 0) {
co++;
n = n / 2;
}
if (co > 0)
v.pb({2, co});
for (int i = 3; i <= sqrt(n); i = i + 2) {
co = 0;
while (n % i == 0) {
co++;
n = n / i;
}
if (co > 0) {
v.pb({i, co});
}
}
if (n > 2)
v.pb({n, 1});
return v;
}
//.................................................................................................................//
// int spf[MAXN];
// void seive()
// {
// spf[1] = 1;
// for (int i=2; i<MAXN; i++)
// spf[i] = i;
// for (int i=4; i<MAXN; i+=2)
// spf[i] = 2;
// for (int i=3; i*i<MAXN; i++)
// {
// if (spf[i] == i)
// {
// for (int j=i*i; j<MAXN; j+=i)
// if (spf[j]==j)
// spf[j] = i;
// }
// }
// }
// //call seive
// vector<pp<int,int>> seiveprimefactors(int x)
// {
// int i=0;
// vector<pp<int,int>> ret;
// while (x != 1)
// {
// if(i==0)
// {
// ret.push_back({spf[x],1});
// i++;
// }
// else
// {
// int si=ret.size()-1;
// if(spf[x]==ret[si].ff)
// {
// ret[si].ss++;
// }
// else
// {
// ret.pb({spf[x],1});
// }
// }
// x = x / spf[x];
// }
// return ret;
// }
//......................................................................................//
bool isprime(int n) {
for (int i = 2; i <= sqrt(n); i++)
if (n % i == 0)
return false;
return true;
}
//........................................................................................//
int maxarr(int *a, int n) {
int val = a[0];
for (int i = 1; i < n; i++) {
if (val < a[i]) {
val = a[i];
}
}
return val;
}
//..........................................................................................//
int minarr(int *a, int n) {
int val = a[0];
for (int i = 1; i < n; i++) {
if (val > a[i]) {
val = a[i];
}
}
return val;
}
//..........................................................................................//
int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
//............................................................................................//
int power(int x, int y, unsigned int p = ULLONG_MAX) {
int res = 1;
x = x % p;
if (x == 0)
return 0;
while (y > 0) {
if (y & 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
//................................................................................................//
bool cmp(const pair<int, int> &a, const pair<int, int> &b) {
if (a.ss < b.ss)
return true;
else if (a.ss > b.ss)
return false;
else {
if (a.ff < b.ff)
return true;
else
return false;
}
}
bool cmp1(const pair<int, int> &a, const pair<int, int> &b) {
return (a.ss < b.ss);
}
//..................................................................................................//
// if no test cases add coments for reading
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
// cin>>t;
while (t--) {
int n;
cin >> n;
int a[n + 1][3] = {0};
for (int i = 1; i <= n; i++) {
for (int j = 0; j < n; j++) {
cin >> a[i][j];
if (j == 0) {
a[i][j] += max(a[i - 1][1], a[i - 1][2]);
} else if (j == 1) {
a[i][j] += max(a[i - 1][0], a[i - 1][2]);
} else {
a[i][j] += max(a[i - 1][1], a[i - 1][0]);
}
// cout<<a[i][j]<<" ";
}
// cout<<endl;
}
int max = ninf;
for (int j = 0; j < 3; j++) {
if (max < a[n][j]) {
max = a[n][j];
}
}
cout << max;
}
}
| #include <bits/stdc++.h>
#define int long long int
#define endl '\n'
#define pb push_back
#define mod 1000000007
#define db(i) cout << i << " ";
#define db1(i) cout << "(" << i << ")";
#define db2(i) cout << "[" << i << "]";
#define db3(i) cout << "{" << i << "}";
#define ff first
#define ss second
#define vv vector
#define pp pair
#define pi acos(-1);
#define printarr(a, n) \
cout << "["; \
for (int i = 0; i < n; i++) { \
db1(a[i]); \
} \
cout << "]";
#define inf LLONG_MAX
#define ninf LLONG_MIN
#define MAXN 100001
using namespace std;
//..................................................................................................//
vector<int> prime;
int fprime = 0;
void seiveprime(int n) {
fprime = 123;
bool pr[n + 1];
memset(pr, true, sizeof(pr));
for (int p = 2; p * p <= n; p++) {
if (pr[p] == true) {
for (int i = p * p; i <= n; i += p)
pr[i] = false;
}
}
for (int p = 2; p <= n; p++)
if (pr[p])
prime.pb(p);
}
//...................................................................................................//
vector<pp<int, int>> primefactors(int n) {
vector<pp<int, int>> v;
int co = 0;
while (n % 2 == 0) {
co++;
n = n / 2;
}
if (co > 0)
v.pb({2, co});
for (int i = 3; i <= sqrt(n); i = i + 2) {
co = 0;
while (n % i == 0) {
co++;
n = n / i;
}
if (co > 0) {
v.pb({i, co});
}
}
if (n > 2)
v.pb({n, 1});
return v;
}
//.................................................................................................................//
// int spf[MAXN];
// void seive()
// {
// spf[1] = 1;
// for (int i=2; i<MAXN; i++)
// spf[i] = i;
// for (int i=4; i<MAXN; i+=2)
// spf[i] = 2;
// for (int i=3; i*i<MAXN; i++)
// {
// if (spf[i] == i)
// {
// for (int j=i*i; j<MAXN; j+=i)
// if (spf[j]==j)
// spf[j] = i;
// }
// }
// }
// //call seive
// vector<pp<int,int>> seiveprimefactors(int x)
// {
// int i=0;
// vector<pp<int,int>> ret;
// while (x != 1)
// {
// if(i==0)
// {
// ret.push_back({spf[x],1});
// i++;
// }
// else
// {
// int si=ret.size()-1;
// if(spf[x]==ret[si].ff)
// {
// ret[si].ss++;
// }
// else
// {
// ret.pb({spf[x],1});
// }
// }
// x = x / spf[x];
// }
// return ret;
// }
//......................................................................................//
bool isprime(int n) {
for (int i = 2; i <= sqrt(n); i++)
if (n % i == 0)
return false;
return true;
}
//........................................................................................//
int maxarr(int *a, int n) {
int val = a[0];
for (int i = 1; i < n; i++) {
if (val < a[i]) {
val = a[i];
}
}
return val;
}
//..........................................................................................//
int minarr(int *a, int n) {
int val = a[0];
for (int i = 1; i < n; i++) {
if (val > a[i]) {
val = a[i];
}
}
return val;
}
//..........................................................................................//
int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
//............................................................................................//
int power(int x, int y, unsigned int p = ULLONG_MAX) {
int res = 1;
x = x % p;
if (x == 0)
return 0;
while (y > 0) {
if (y & 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
//................................................................................................//
bool cmp(const pair<int, int> &a, const pair<int, int> &b) {
if (a.ss < b.ss)
return true;
else if (a.ss > b.ss)
return false;
else {
if (a.ff < b.ff)
return true;
else
return false;
}
}
bool cmp1(const pair<int, int> &a, const pair<int, int> &b) {
return (a.ss < b.ss);
}
//..................................................................................................//
// if no test cases add coments for reading
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
// cin>>t;
while (t--) {
int n;
cin >> n;
int a[n + 1][3] = {0};
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 3; j++) {
cin >> a[i][j];
if (j == 0) {
a[i][j] += max(a[i - 1][1], a[i - 1][2]);
} else if (j == 1) {
a[i][j] += max(a[i - 1][0], a[i - 1][2]);
} else {
a[i][j] += max(a[i - 1][1], a[i - 1][0]);
}
// cout<<a[i][j]<<" ";
}
// cout<<endl;
}
int max = ninf;
for (int j = 0; j < 3; j++) {
if (max < a[n][j]) {
max = a[n][j];
}
}
cout << max;
}
}
| [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.condition.change"
] | 962,863 | 962,864 | u054483369 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
// memo fixed setprecision(20);
using vvll = vector<vector<ll>>;
ll mod = 1e9 + 7;
/*"itob" int to "N"base */ template <typename TypeInt>
string itob(const TypeInt v, int base) {
static const char table[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
string ret;
static numeric_limits<TypeInt> t;
TypeInt n = v;
if (t.is_signed) {
if (v < 0)
n *= -1;
}
while (n >= base) {
ret += table[n % base];
n /= base;
}
ret += table[n];
if (t.is_signed) {
if (v < 0 && base == 10)
ret += '-';
}
reverse(ret.begin(), ret.end());
return ret;
}
/*"chmin" a = MAX*/ template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
/*"chmax" a = MIN*/ template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
/*"ctoi" char to int*/ int ctoi(char c) { return c - '0'; }
/*"gcd" MAX Euclidean */ ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
/*"lcm" MIN*/ ll lcm(ll a, ll b) {
ll g = gcd(a, b);
return a / g * b;
}
/*"primecheck"If prime,return true.*/ bool primecheck(ll n) {
if (n < 2)
return false;
else {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
}
string reverserange(string s, ll a, ll b) {
reverse(s.begin() + a - 1, s.begin() + b);
return s;
}
ll modpow(ll a, ll n, ll mod) {
ll res = 1;
while (n > 0) {
if (n % 2 == 1) {
res = res * a % mod;
}
a = a * a % mod;
n /= 2;
}
return res;
}
int main() {
ll n;
cin >> n;
ll che[n][3];
for (int i = 0; i < n; i++) {
cin >> che[i][0] >> che[i][1] >> che[i][2];
}
ll dp[n + 1][3];
for (int i = 0; i <= n; i++) {
for (int j = 0; j < 3; j++) {
dp[i][j] = 0;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
if (j == k)
continue;
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j] + che[i][k]);
}
}
}
ll ans = 0;
for (int i = 0; i < 3; i++) {
ans = max(ans, dp[n][i]);
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
// memo fixed setprecision(20);
using vvll = vector<vector<ll>>;
ll mod = 1e9 + 7;
/*"itob" int to "N"base */ template <typename TypeInt>
string itob(const TypeInt v, int base) {
static const char table[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
string ret;
static numeric_limits<TypeInt> t;
TypeInt n = v;
if (t.is_signed) {
if (v < 0)
n *= -1;
}
while (n >= base) {
ret += table[n % base];
n /= base;
}
ret += table[n];
if (t.is_signed) {
if (v < 0 && base == 10)
ret += '-';
}
reverse(ret.begin(), ret.end());
return ret;
}
/*"chmin" a = MAX*/ template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
/*"chmax" a = MIN*/ template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
/*"ctoi" char to int*/ int ctoi(char c) { return c - '0'; }
/*"gcd" MAX Euclidean */ ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
/*"lcm" MIN*/ ll lcm(ll a, ll b) {
ll g = gcd(a, b);
return a / g * b;
}
/*"primecheck"If prime,return true.*/ bool primecheck(ll n) {
if (n < 2)
return false;
else {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
}
string reverserange(string s, ll a, ll b) {
reverse(s.begin() + a - 1, s.begin() + b);
return s;
}
ll modpow(ll a, ll n, ll mod) {
ll res = 1;
while (n > 0) {
if (n % 2 == 1) {
res = res * a % mod;
}
a = a * a % mod;
n /= 2;
}
return res;
}
int main() {
ll n;
cin >> n;
ll che[n][3];
for (int i = 0; i < n; i++) {
cin >> che[i][0] >> che[i][1] >> che[i][2];
}
ll dp[n + 1][3];
for (int i = 0; i <= n; i++) {
for (int j = 0; j < 3; j++) {
dp[i][j] = 0;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
if (j == k)
continue;
dp[i + 1][j] = max(dp[i + 1][j], dp[i][k] + che[i][j]);
}
}
}
ll ans = 0;
for (int i = 0; i < 3; i++) {
ans = max(ans, dp[n][i]);
}
cout << ans << endl;
}
| [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 962,867 | 962,868 | u157433024 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
// memo fixed setprecision(20);
using vvll = vector<vector<ll>>;
ll mod = 1e9 + 7;
/*"itob" int to "N"base */ template <typename TypeInt>
string itob(const TypeInt v, int base) {
static const char table[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
string ret;
static numeric_limits<TypeInt> t;
TypeInt n = v;
if (t.is_signed) {
if (v < 0)
n *= -1;
}
while (n >= base) {
ret += table[n % base];
n /= base;
}
ret += table[n];
if (t.is_signed) {
if (v < 0 && base == 10)
ret += '-';
}
reverse(ret.begin(), ret.end());
return ret;
}
/*"chmin" a = MAX*/ template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
/*"chmax" a = MIN*/ template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
/*"ctoi" char to int*/ int ctoi(char c) { return c - '0'; }
/*"gcd" MAX Euclidean */ ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
/*"lcm" MIN*/ ll lcm(ll a, ll b) {
ll g = gcd(a, b);
return a / g * b;
}
/*"primecheck"If prime,return true.*/ bool primecheck(ll n) {
if (n < 2)
return false;
else {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
}
string reverserange(string s, ll a, ll b) {
reverse(s.begin() + a - 1, s.begin() + b);
return s;
}
ll modpow(ll a, ll n, ll mod) {
ll res = 1;
while (n > 0) {
if (n % 2 == 1) {
res = res * a % mod;
}
a = a * a % mod;
n /= 2;
}
return res;
}
int main() {
ll n;
cin >> n;
ll che[n][3];
for (int i = 0; i < n; i++) {
cin >> che[i][0] >> che[i][1] >> che[i][2];
}
ll dp[n + 1][3];
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= 3; j++) {
dp[i][j] = 0;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
if (j == k)
continue;
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j] + che[i][k]);
}
}
}
ll ans = 0;
for (int i = 0; i < 3; i++) {
ans = max(ans, dp[n][i]);
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
// memo fixed setprecision(20);
using vvll = vector<vector<ll>>;
ll mod = 1e9 + 7;
/*"itob" int to "N"base */ template <typename TypeInt>
string itob(const TypeInt v, int base) {
static const char table[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
string ret;
static numeric_limits<TypeInt> t;
TypeInt n = v;
if (t.is_signed) {
if (v < 0)
n *= -1;
}
while (n >= base) {
ret += table[n % base];
n /= base;
}
ret += table[n];
if (t.is_signed) {
if (v < 0 && base == 10)
ret += '-';
}
reverse(ret.begin(), ret.end());
return ret;
}
/*"chmin" a = MAX*/ template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
/*"chmax" a = MIN*/ template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
/*"ctoi" char to int*/ int ctoi(char c) { return c - '0'; }
/*"gcd" MAX Euclidean */ ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
/*"lcm" MIN*/ ll lcm(ll a, ll b) {
ll g = gcd(a, b);
return a / g * b;
}
/*"primecheck"If prime,return true.*/ bool primecheck(ll n) {
if (n < 2)
return false;
else {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
}
string reverserange(string s, ll a, ll b) {
reverse(s.begin() + a - 1, s.begin() + b);
return s;
}
ll modpow(ll a, ll n, ll mod) {
ll res = 1;
while (n > 0) {
if (n % 2 == 1) {
res = res * a % mod;
}
a = a * a % mod;
n /= 2;
}
return res;
}
int main() {
ll n;
cin >> n;
ll che[n][3];
for (int i = 0; i < n; i++) {
cin >> che[i][0] >> che[i][1] >> che[i][2];
}
ll dp[n + 1][3];
for (int i = 0; i <= n; i++) {
for (int j = 0; j < 3; j++) {
dp[i][j] = 0;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
if (j == k)
continue;
dp[i + 1][j] = max(dp[i + 1][j], dp[i][k] + che[i][j]);
}
}
}
ll ans = 0;
for (int i = 0; i < 3; i++) {
ans = max(ans, dp[n][i]);
}
cout << ans << endl;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change"
] | 962,869 | 962,868 | u157433024 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
// memo fixed setprecision(20);
using vvll = vector<vector<ll>>;
ll mod = 1e9 + 7;
/*"itob" int to "N"base */ template <typename TypeInt>
string itob(const TypeInt v, int base) {
static const char table[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
string ret;
static numeric_limits<TypeInt> t;
TypeInt n = v;
if (t.is_signed) {
if (v < 0)
n *= -1;
}
while (n >= base) {
ret += table[n % base];
n /= base;
}
ret += table[n];
if (t.is_signed) {
if (v < 0 && base == 10)
ret += '-';
}
reverse(ret.begin(), ret.end());
return ret;
}
/*"chmin" a = MAX*/ template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
/*"chmax" a = MIN*/ template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
/*"ctoi" char to int*/ int ctoi(char c) { return c - '0'; }
/*"gcd" MAX Euclidean */ ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
/*"lcm" MIN*/ ll lcm(ll a, ll b) {
ll g = gcd(a, b);
return a / g * b;
}
/*"primecheck"If prime,return true.*/ bool primecheck(ll n) {
if (n < 2)
return false;
else {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
}
string reverserange(string s, ll a, ll b) {
reverse(s.begin() + a - 1, s.begin() + b);
return s;
}
ll modpow(ll a, ll n, ll mod) {
ll res = 1;
while (n > 0) {
if (n % 2 == 1) {
res = res * a % mod;
}
a = a * a % mod;
n /= 2;
}
return res;
}
int main() {
ll n;
cin >> n;
ll che[n][3];
for (int i = 0; i < n; i++) {
cin >> che[i][0] >> che[i][1] >> che[i][2];
}
ll dp[n + 1][3];
for (int i = 0; i <= n; i++) {
for (int j = 0; j < 3; j++) {
dp[i][j] = 0;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
if (j == k)
continue;
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j] + che[i][k]);
}
}
}
ll ans = 0;
for (int i = 0; i < 3; i++) {
ans = max(ans, dp[n][i]);
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
// memo fixed setprecision(20);
using vvll = vector<vector<ll>>;
ll mod = 1e9 + 7;
/*"itob" int to "N"base */ template <typename TypeInt>
string itob(const TypeInt v, int base) {
static const char table[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
string ret;
static numeric_limits<TypeInt> t;
TypeInt n = v;
if (t.is_signed) {
if (v < 0)
n *= -1;
}
while (n >= base) {
ret += table[n % base];
n /= base;
}
ret += table[n];
if (t.is_signed) {
if (v < 0 && base == 10)
ret += '-';
}
reverse(ret.begin(), ret.end());
return ret;
}
/*"chmin" a = MAX*/ template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
/*"chmax" a = MIN*/ template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
/*"ctoi" char to int*/ int ctoi(char c) { return c - '0'; }
/*"gcd" MAX Euclidean */ ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
/*"lcm" MIN*/ ll lcm(ll a, ll b) {
ll g = gcd(a, b);
return a / g * b;
}
/*"primecheck"If prime,return true.*/ bool primecheck(ll n) {
if (n < 2)
return false;
else {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
}
string reverserange(string s, ll a, ll b) {
reverse(s.begin() + a - 1, s.begin() + b);
return s;
}
ll modpow(ll a, ll n, ll mod) {
ll res = 1;
while (n > 0) {
if (n % 2 == 1) {
res = res * a % mod;
}
a = a * a % mod;
n /= 2;
}
return res;
}
int main() {
ll n;
cin >> n;
ll che[n][3];
for (int i = 0; i < n; i++) {
cin >> che[i][0] >> che[i][1] >> che[i][2];
}
ll dp[n + 1][3];
for (int i = 0; i <= n; i++) {
for (int j = 0; j < 3; j++) {
dp[i][j] = 0;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
if (j == k)
continue;
dp[i + 1][k] = max(dp[i + 1][k], dp[i][j] + che[i][k]);
}
}
}
ll ans = 0;
for (int i = 0; i < 3; i++) {
ans = max(ans, dp[n][i]);
}
cout << ans << endl;
}
| [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change",
"assignment.value.change",
"call.arguments.change"
] | 962,867 | 962,870 | u157433024 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
// memo fixed setprecision(20);
using vvll = vector<vector<ll>>;
ll mod = 1e9 + 7;
/*"itob" int to "N"base */ template <typename TypeInt>
string itob(const TypeInt v, int base) {
static const char table[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
string ret;
static numeric_limits<TypeInt> t;
TypeInt n = v;
if (t.is_signed) {
if (v < 0)
n *= -1;
}
while (n >= base) {
ret += table[n % base];
n /= base;
}
ret += table[n];
if (t.is_signed) {
if (v < 0 && base == 10)
ret += '-';
}
reverse(ret.begin(), ret.end());
return ret;
}
/*"chmin" a = MAX*/ template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
/*"chmax" a = MIN*/ template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
/*"ctoi" char to int*/ int ctoi(char c) { return c - '0'; }
/*"gcd" MAX Euclidean */ ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
/*"lcm" MIN*/ ll lcm(ll a, ll b) {
ll g = gcd(a, b);
return a / g * b;
}
/*"primecheck"If prime,return true.*/ bool primecheck(ll n) {
if (n < 2)
return false;
else {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
}
string reverserange(string s, ll a, ll b) {
reverse(s.begin() + a - 1, s.begin() + b);
return s;
}
ll modpow(ll a, ll n, ll mod) {
ll res = 1;
while (n > 0) {
if (n % 2 == 1) {
res = res * a % mod;
}
a = a * a % mod;
n /= 2;
}
return res;
}
int main() {
ll n;
cin >> n;
ll che[n][3];
for (int i = 0; i < n; i++) {
cin >> che[i][0] >> che[i][1] >> che[i][2];
}
ll dp[n + 1][3];
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= 3; j++) {
dp[i][j] = 0;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
if (j == k)
continue;
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j] + che[i][k]);
}
}
}
ll ans = 0;
for (int i = 0; i < 3; i++) {
ans = max(ans, dp[n][i]);
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
// memo fixed setprecision(20);
using vvll = vector<vector<ll>>;
ll mod = 1e9 + 7;
/*"itob" int to "N"base */ template <typename TypeInt>
string itob(const TypeInt v, int base) {
static const char table[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
string ret;
static numeric_limits<TypeInt> t;
TypeInt n = v;
if (t.is_signed) {
if (v < 0)
n *= -1;
}
while (n >= base) {
ret += table[n % base];
n /= base;
}
ret += table[n];
if (t.is_signed) {
if (v < 0 && base == 10)
ret += '-';
}
reverse(ret.begin(), ret.end());
return ret;
}
/*"chmin" a = MAX*/ template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
/*"chmax" a = MIN*/ template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
/*"ctoi" char to int*/ int ctoi(char c) { return c - '0'; }
/*"gcd" MAX Euclidean */ ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
/*"lcm" MIN*/ ll lcm(ll a, ll b) {
ll g = gcd(a, b);
return a / g * b;
}
/*"primecheck"If prime,return true.*/ bool primecheck(ll n) {
if (n < 2)
return false;
else {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
}
string reverserange(string s, ll a, ll b) {
reverse(s.begin() + a - 1, s.begin() + b);
return s;
}
ll modpow(ll a, ll n, ll mod) {
ll res = 1;
while (n > 0) {
if (n % 2 == 1) {
res = res * a % mod;
}
a = a * a % mod;
n /= 2;
}
return res;
}
int main() {
ll n;
cin >> n;
ll che[n][3];
for (int i = 0; i < n; i++) {
cin >> che[i][0] >> che[i][1] >> che[i][2];
}
ll dp[n + 1][3];
for (int i = 0; i <= n; i++) {
for (int j = 0; j < 3; j++) {
dp[i][j] = 0;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
if (j == k)
continue;
dp[i + 1][k] = max(dp[i + 1][k], dp[i][j] + che[i][k]);
}
}
}
ll ans = 0;
for (int i = 0; i < 3; i++) {
ans = max(ans, dp[n][i]);
}
cout << ans << endl;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change",
"assignment.value.change",
"call.arguments.change"
] | 962,869 | 962,870 | u157433024 | cpp |
p03162 | #include <bits/stdc++.h>
#define IO \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define int long long
using namespace std;
const int MX = 1e5 + 5;
int dp[MX][4];
vector<vector<int>> v;
int n;
int solve(int days, int prev) {
if (days == n + 1)
return 0;
if (dp[days][prev] != -1)
return dp[days][prev];
long long ans = -1e17;
for (int i = 1; i <= 3; i++) {
if (i != prev) {
ans = max(ans, solve(days + 1, i) + v[days][i]);
}
}
return dp[prev][prev] = ans;
}
int32_t main() {
memset(dp, -1, sizeof dp);
cin >> n;
v.resize(n + 1);
for (int i = 1; i <= n; i++) {
v[i].resize(4);
for (int j = 1; j <= 3; j++)
cin >> v[i][j];
}
cout << solve(1, 0);
return 0;
}
| #include <bits/stdc++.h>
#define IO \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define int long long
using namespace std;
const int MX = 1e5 + 5;
int dp[MX][4];
vector<vector<int>> v;
int n;
int solve(int days, int prev) {
if (days == n + 1)
return 0;
if (dp[days][prev] != -1)
return dp[days][prev];
long long ans = -1e17;
for (int i = 1; i <= 3; i++) {
if (i != prev) {
ans = max(ans, solve(days + 1, i) + v[days][i]);
}
}
return dp[days][prev] = ans;
}
int32_t main() {
memset(dp, -1, sizeof dp);
cin >> n;
v.resize(n + 1);
for (int i = 1; i <= n; i++) {
v[i].resize(4);
for (int j = 1; j <= 3; j++)
cin >> v[i][j];
}
cout << solve(1, 0);
return 0;
}
| [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change",
"function.return_value.change"
] | 962,873 | 962,874 | u543083821 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define db double
#define ld long double
#define rep(i, n) for (int i = 0; i < n; i++)
#define rev(i, n) for (int i = n; i >= 0; i--)
#define rep_a(i, a, n) for (int i = a; i < n; i++)
#define pb push_back
#define fast \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define sz(v) ((int)(v).size())
#define all(v) (v).begin(), (v).end()
int solve() {
int n;
cin >> n;
vector<int> dp(3, 0);
rep(i, n) {
vector<int> val(3);
vector<int> new_dp(3, 0);
rep(j, 3) { cin >> val[j]; }
rep(j, 3) {
rep(k, 3) {
if (j != k) {
new_dp[j] = max(new_dp[j], dp[j] + val[k]);
}
}
}
dp = new_dp;
}
cout << max({dp[0], dp[1], dp[2]}) << endl;
return 0;
}
int main() {
/* #ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#else
#endif */
solve();
/* #ifndef ONLINE_JUDGE
cout<<"\nTime Elapsed: "<<1.0*clock()/ CLOCKS_PER_SEC<<" Sec\n";
#endif */
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define db double
#define ld long double
#define rep(i, n) for (int i = 0; i < n; i++)
#define rev(i, n) for (int i = n; i >= 0; i--)
#define rep_a(i, a, n) for (int i = a; i < n; i++)
#define pb push_back
#define fast \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define sz(v) ((int)(v).size())
#define all(v) (v).begin(), (v).end()
int solve() {
int n;
cin >> n;
vector<int> dp(3, 0);
rep(i, n) {
vector<int> val(3);
vector<int> new_dp(3, 0);
rep(j, 3) { cin >> val[j]; }
rep(j, 3) {
rep(k, 3) {
if (j != k) {
new_dp[k] = max(new_dp[k], dp[j] + val[k]);
}
}
}
dp = new_dp;
}
cout << max({dp[0], dp[1], dp[2]}) << endl;
return 0;
}
int main() {
/* #ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#else
#endif */
solve();
/* #ifndef ONLINE_JUDGE
cout<<"\nTime Elapsed: "<<1.0*clock()/ CLOCKS_PER_SEC<<" Sec\n";
#endif */
return 0;
} | [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change",
"assignment.value.change",
"call.arguments.change"
] | 962,877 | 962,878 | u296273488 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long dp[100010][3], a[100010][3];
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
cin >> a[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
if (j == k)
continue;
dp[i + 1][k] = max(dp[i + 1][k], dp[i][j] + dp[i][k]);
}
}
}
long long res = 0;
for (int j = 0; j < 3; j++) {
res = max(res, dp[n][j]);
}
cout << res << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long dp[100010][3];
long long a[100010][3];
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
cin >> a[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
if (j == k)
continue;
dp[i + 1][k] = max(dp[i + 1][k], dp[i][j] + a[i][k]);
}
}
}
long long res = 0;
for (int j = 0; j < 3; j++) {
res = max(res, dp[n][j]);
}
cout << res << endl;
} | [
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 962,879 | 962,880 | u147762850 | cpp |
p03162 | #include <bits/stdc++.h>
#define ll long long
using namespace std;
int main() {
ll n;
cin >> n;
vector<vector<ll>> a(n, vector<ll>(3));
for (int i = 0; i < n; i++) {
cin >> a[i][0];
cin >> a[i][1];
cin >> a[i][2];
}
vector<vector<ll>> dp(n, vector<ll>(3));
dp[0][0] = a[0][0];
dp[0][1] = a[0][1];
dp[0][2] = a[0][2];
for (int i = 1; i < n; i++) {
dp[i][0] = max(dp[i - 1][1], dp[i - 1][2]) + a[i][0];
dp[i][1] = max(dp[i - 1][0], dp[i - 1][2]) + a[i][2];
dp[i][2] = max(dp[i - 1][0], dp[i - 1][2]) + a[i][1];
}
cout << max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2]));
} | #include <bits/stdc++.h>
#define ll long long
using namespace std;
int main() {
ll n;
cin >> n;
vector<vector<ll>> a(n, vector<ll>(3));
for (int i = 0; i < n; i++) {
cin >> a[i][0];
cin >> a[i][1];
cin >> a[i][2];
}
vector<vector<ll>> dp(n, vector<ll>(3));
dp[0][0] = a[0][0];
dp[0][1] = a[0][1];
dp[0][2] = a[0][2];
for (int i = 1; i < n; i++) {
dp[i][0] = max(dp[i - 1][1], dp[i - 1][2]) + a[i][0];
dp[i][1] = max(dp[i - 1][0], dp[i - 1][2]) + a[i][1];
dp[i][2] = max(dp[i - 1][0], dp[i - 1][1]) + a[i][2];
}
cout << max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2]));
} | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 962,889 | 962,891 | u272668049 | cpp |
p03162 | #include <iostream>
#include <vector>
int main(int argc, char *argv[]) {
int n;
std::cin >> n;
std::vector<std::vector<int>> a(n, std::vector<int>(n));
for (int i = 0; i < n; ++i)
for (int j = 0; j < 3; ++j)
std::cin >> a.at(i).at(j);
std::vector<std::vector<long>> dp(n + 1, std::vector<long>(3, 0));
for (int i = 0; i < n; ++i)
for (int j = 0; j < 3; ++j)
for (int k = 0; k < 3; ++k) {
if (j != k)
dp.at(i + 1).at(j) =
std::max(dp.at(i + 1).at(j), dp.at(i).at(k) + a.at(i).at(j));
}
long ans = 0;
for (auto i : dp.at(n))
ans = std::max(ans, i);
std::cout << ans << std::endl;
}
| #include <iostream>
#include <vector>
int main(int argc, char *argv[]) {
int n;
std::cin >> n;
std::vector<std::vector<int>> a(n, std::vector<int>(3));
for (int i = 0; i < n; ++i)
for (int j = 0; j < 3; ++j)
std::cin >> a.at(i).at(j);
std::vector<std::vector<int>> dp(n + 1, std::vector<int>(3, 0));
for (int i = 0; i < n; ++i)
for (int j = 0; j < 3; ++j)
for (int k = 0; k < 3; ++k) {
if (j != k)
dp.at(i + 1).at(j) =
std::max(dp.at(i + 1).at(j), dp.at(i).at(k) + a.at(i).at(j));
}
int ans = 0;
for (auto i : dp.at(n))
ans = std::max(ans, i);
std::cout << ans << std::endl;
}
| [
"variable_declaration.type.primitive.change"
] | 962,893 | 962,894 | u089888152 | cpp |
p03162 | #include <iostream>
#include <vector>
int main(int argc, char *argv[]) {
int n;
std::cin >> n;
std::vector<std::vector<int>> a(n, std::vector<int>(n));
for (int i = 0; i < n; ++i)
for (int j = 0; j < 3; ++j)
std::cin >> a.at(i).at(j);
std::vector<std::vector<int>> dp(n + 1, std::vector<int>(3, 0));
for (int i = 0; i < n; ++i)
for (int j = 0; j < 3; ++j)
for (int k = 0; k < 3; ++k) {
if (j != k)
dp.at(i + 1).at(j) =
std::max(dp.at(i + 1).at(j), dp.at(i).at(k) + a.at(i).at(j));
}
int ans = 0;
for (auto i : dp.at(n))
ans = std::max(ans, i);
std::cout << ans << std::endl;
}
| #include <iostream>
#include <vector>
int main(int argc, char *argv[]) {
int n;
std::cin >> n;
std::vector<std::vector<int>> a(n, std::vector<int>(3));
for (int i = 0; i < n; ++i)
for (int j = 0; j < 3; ++j)
std::cin >> a.at(i).at(j);
std::vector<std::vector<int>> dp(n + 1, std::vector<int>(3, 0));
for (int i = 0; i < n; ++i)
for (int j = 0; j < 3; ++j)
for (int k = 0; k < 3; ++k) {
if (j != k)
dp.at(i + 1).at(j) =
std::max(dp.at(i + 1).at(j), dp.at(i).at(k) + a.at(i).at(j));
}
int ans = 0;
for (auto i : dp.at(n))
ans = std::max(ans, i);
std::cout << ans << std::endl;
}
| [] | 962,895 | 962,894 | u089888152 | cpp |
p03162 | #include <climits>
#include <iostream>
using namespace std;
long long int points[100000][3];
long long int dp[100000][3];
long long int max_points(int p, int n) {
if (n < 0) {
return 0;
}
if (dp[n][p] != -1) {
return dp[n][p];
}
long long int current = LLONG_MIN;
for (int i = 0; i < 3; i++) {
if (p != i) {
current = max(current, max_points(i, n - 1) + points[n][i]);
}
}
return dp[n][p] = current;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> points[i][0] >> points[i][1] >> points[i][2];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
dp[i][j] = -1;
}
}
cout << max_points(-1, n - 1) << endl;
return 0;
} | #include <climits>
#include <iostream>
using namespace std;
long long int points[100000][3];
long long int dp[100000][3];
long long int max_points(int p, int n) {
if (n < 0) {
return 0;
}
if (p != -1 && dp[n][p] != -1) {
return dp[n][p];
}
long long int current = LLONG_MIN;
for (int i = 0; i < 3; i++) {
if (p != i) {
current = max(current, max_points(i, n - 1) + points[n][i]);
}
}
return dp[n][p] = current;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> points[i][0] >> points[i][1] >> points[i][2];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
dp[i][j] = -1;
}
}
cout << max_points(-1, n - 1) << endl;
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 962,896 | 962,897 | u959838921 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int a[100005][4];
int dp[100005][4];
int n;
int solve(int day, int flag) {
if (day == n)
return 0;
if (dp[day][flag] != -1)
return dp[day][flag];
int maxi = 0;
if (flag == 0) {
maxi = max(maxi, a[day][1] + solve(day + 1, 1));
maxi = max(maxi, a[day][2] + solve(day + 1, 2));
maxi = max(maxi, a[day][3] + solve(day + 1, 3));
} else if (flag == 1) {
maxi = max(maxi, a[day][2] + solve(day + 1, 2));
maxi = max(maxi, a[day][3] + solve(day + 1, 3));
} else if (flag == 2) {
maxi = max(maxi, a[day][1] + solve(day + 1, 1));
maxi = max(maxi, a[day][3] + solve(day + 1, 2));
} else {
maxi = max(maxi, a[day][1] + solve(day + 1, 1));
maxi = max(maxi, a[day][2] + solve(day + 1, 2));
}
return dp[day][flag] = maxi;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= 3; j++)
cin >> a[i][j];
}
memset(dp, -1, sizeof(dp));
cout << solve(0, 0);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int a[100005][4];
int dp[100005][4];
int n;
int solve(int day, int flag) {
if (day == n)
return 0;
if (dp[day][flag] != -1)
return dp[day][flag];
int maxi = 0;
if (flag == 0) {
maxi = max(maxi, a[day][1] + solve(day + 1, 1));
maxi = max(maxi, a[day][2] + solve(day + 1, 2));
maxi = max(maxi, a[day][3] + solve(day + 1, 3));
} else if (flag == 1) {
maxi = max(maxi, a[day][2] + solve(day + 1, 2));
maxi = max(maxi, a[day][3] + solve(day + 1, 3));
} else if (flag == 2) {
maxi = max(maxi, a[day][1] + solve(day + 1, 1));
maxi = max(maxi, a[day][3] + solve(day + 1, 3));
} else {
maxi = max(maxi, a[day][1] + solve(day + 1, 1));
maxi = max(maxi, a[day][2] + solve(day + 1, 2));
}
return dp[day][flag] = maxi;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= 3; j++)
cin >> a[i][j];
}
memset(dp, -1, sizeof(dp));
cout << solve(0, 0);
return 0;
} | [
"literal.number.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 962,964 | 962,965 | u552762884 | cpp |
p03162 | /* *MELLOW THE PANDA*
`||||||||||||||||||||||!!!||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
`||||||||||||||||||!''
!!||||pp@@@@@@@@@@@@@@@@@@@@@@||||||!'````````||||||||||||||||
|||||||||||||||!'` ,g@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@L `|||||||||||||||
'||||||||||||'` ,p@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ `||||||||||||||
'|||||||||||' j@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@w ``||||||||||||
'||||||||||` ,g@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@,
`||||||||||||
||||||||||' ,@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@L
`|||||||||||
'||||||||| @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@p
`'||||||||||
'|||||||||;, /@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@,
`<|||||||||||
'|||||||||||!;p@@@@@@@@M*
**%@&@F***********&@@@@@@N%@@@@@@@@@@@@@@@@w!||||||||||||||
'||||||||||||j@@@@@@@N |!"*!,@@@@@[ &@@&@@m
?@@@@@@@@g||||||||||||||||
'||||||||||||]@@@@@@@ || #r)@@@@@@$, g@@@@@@@@|"""!|;
]@@@@@@@@@@||||||||||||||
`||||||||||||]@@@@@@| || g@@@@@@@@@@p ,@@@@@&@@@@@@|#L !|
%@@@@@@@@@k|||||||||||||
`||||||||||||]@@@@@@ `||$@@@@N@@@@@@&@$@@$@@@@@@@@@@@@@ ||
]%@@@@@@@@H|||||||||||||
`||||||||||||]@@@@@@ ^@@@@@NM@@@@@@@@@ |@@@@@@@@@@@@@@''`
%@@@@@@%%||||||||||||||
||||||||||||%@@@@@@ ]B@@@@@@|&@@@@@@@M$@@@@@@@@@/@@@@@
]@@@@@@@%!!!|||||||||||
'|||||||||||]@@@@@@o @@@@@@@@@|N@@@@@ @@@@@@@@@|@@@@@@ ]@@@@@@@%
```'|||||||||
'|||||||||||]@@@@@@@ ]@@@@@@@@@@]%@N@ Q@@@@%@[]@@@@@@N p@@@@@@%M
`|||||||
`||||||||||||]@@@@@@@; %N@@@@@@@@@@@@Lj@@gg@@@@@@N@@@N )@@@@@@@@F '||||||
`|||||||||||||]%@@@@@@@r %@@@@@@@@@@@@@@@@@@@@@@@@@@@K ]@@@@@@@@h '`||||||
`||||||||||||||]@%N%N@@@gm,, j%@@@@@@@@@@@@@@@@@@@@@%h ;p@@@@@@@@@F `||||||
`|||||||||||||||j%@@@@@@@@@p".. ,,;g@@@@@@@@@@*" `||||||
`||||||||||||||||||]%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@k@]N" '||||||
`|||||||||||||||'``'"@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@**'``` |||||||
`||||||||||||||'|` '*@@@@@@@@@@@@@@@@@@@`` y||||||
`'||||||||||||'` ''"**||||||||||| j|||||||
``|||||||||||` `'`'|jk* ,j||||||||
`'||||||||||| '` ;p||||||||||
``||||||||||' `'*j||||||
``||||||||||| ||
___________________________________________________________________________________________________________________________________________________________*/
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace std;
using namespace __gnu_pbds;
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define mellow \
ios_base::sync_with_stdio(0); \
cin.tie(0)
#define qa \
cout << "------------" \
<< "\n"
#define fo(i, n) for (ll i = 0; i < n; i++)
#define Fo(i, k, n) for (ll i = k; i < n; i++)
#define ll long long
#define deb(x) cout << #x << "=" << x << endl
#define deb2(x, y) cout << #x << "=" << x << "," << #y << "=" << y << endl
#define debV(arr) \
cout << #arr << ": "; \
for (int qwe = 0; qwe < arr.size(); qwe++) \
cout << arr[qwe] << " "; \
cout << "\n"
#define debVV(arr) \
for (int ewq = 0; ewq < arr.size(); ewq++) { \
for (int ews = 0; ews < arr[ewq].size(); ews++) \
cout << arr[ewq][ews] << " "; \
cout << endl; \
} \
cout << endl;
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define all(x) x.begin(), x.end()
#define clr(x) memset(x, 0, sizeof(x))
#define sortall(x) sort(all(x))
#define trav(it, a) for (auto it = a.begin(); it != a.end(); it++)
#define pres(a, x) ((a).find(x) != (a).end())
#define PI 3.1415926535897932384626
#define endl "\n"
#define mod 1000000007
#define sz(x) (int)x.size()
#define vvl(name, rowsize, colsize) \
vector<vector<ll>> name((rowsize), vector<ll>(colsize));
#define vvl0(name, rowsize, colsize) \
vector<vector<ll>> name((rowsize), vector<ll>(colsize, 0));
#define meme(ssss) \
for (int zasi = 0; zasi < ssss.size(); zasi++) { \
for (int zasj = 0; zasj < ssss[zasi].size(); zasj++) \
ssss[zasi][zasj] = 0; \
}
#define LLM LONG_LONG_MAX
typedef tree<ll, null_type, less<ll>, rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<string> vs;
vi X = {0, -1, 0, 1};
vi Y = {-1, 0, 1, 0};
ll powerFast(ll a, ll b) {
if (b == 0)
return 1;
ll c = powerFast(a, b / 2);
if (b % 2 == 0)
return ((c % mod) * (c % mod)) % mod;
else
return ((((c % mod) * (c % mod)) % mod) * a) % mod;
}
ll powerFast2(ll a, ll b) {
if (b == 0)
return 1;
ll c = powerFast(a, b / 2);
if (b % 2 == 0)
return ((c) * (c));
else
return ((((c) * (c))) * a);
}
// add custom hash infront of unordered_map and gp_hash_table
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
//____________________________________________________________________________________________________________________________________________________________
ll n = 0;
ll dp(vector<vll> &a, vector<vll> &arrDp, ll index, ll flag) {
if (index == n)
return 0;
ll ans = 0;
if (arrDp[index][flag] != -1)
return arrDp[index][flag];
if (n == 0) {
ans = max(a[index][0] + dp(a, arrDp, index + 1, 0), ans);
ans = max(a[index][1] + dp(a, arrDp, index + 1, 1), ans);
ans = max(a[index][2] + dp(a, arrDp, index + 1, 2), ans);
} else {
if (flag == 0) {
ans = max(ans, a[index][1] + dp(a, arrDp, index + 1, 1));
ans = max(ans, a[index][2] + dp(a, arrDp, index + 1, 2));
}
if (flag == 1) {
ans = max(ans, a[index][0] + dp(a, arrDp, index + 1, 0));
ans = max(ans, a[index][2] + dp(a, arrDp, index + 1, 2));
}
if (flag == 2) {
ans = max(ans, a[index][0] + dp(a, arrDp, index + 1, 0));
ans = max(ans, a[index][1] + dp(a, arrDp, index + 1, 1));
}
}
arrDp[index][flag] = ans;
return ans;
}
ll compute() {
cin >> n;
vector<vll> a(n, vll(3, 0));
vector<vll> arrDp(n, vll(3, -1));
for (int i = 0; i < n; i++) {
for (int j = 0; j < a[i].size(); j++)
cin >> a[i][j];
}
return dp(a, arrDp, 0, 0);
}
int main() {
mellow;
ll TESTS = 1;
// cin>>TESTS;
while (TESTS--) {
cout << compute() << "\n";
// compute();
}
return 0;
} | /* *MELLOW THE PANDA*
`||||||||||||||||||||||!!!||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
`||||||||||||||||||!''
!!||||pp@@@@@@@@@@@@@@@@@@@@@@||||||!'````````||||||||||||||||
|||||||||||||||!'` ,g@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@L `|||||||||||||||
'||||||||||||'` ,p@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ `||||||||||||||
'|||||||||||' j@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@w ``||||||||||||
'||||||||||` ,g@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@,
`||||||||||||
||||||||||' ,@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@L
`|||||||||||
'||||||||| @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@p
`'||||||||||
'|||||||||;, /@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@,
`<|||||||||||
'|||||||||||!;p@@@@@@@@M*
**%@&@F***********&@@@@@@N%@@@@@@@@@@@@@@@@w!||||||||||||||
'||||||||||||j@@@@@@@N |!"*!,@@@@@[ &@@&@@m
?@@@@@@@@g||||||||||||||||
'||||||||||||]@@@@@@@ || #r)@@@@@@$, g@@@@@@@@|"""!|;
]@@@@@@@@@@||||||||||||||
`||||||||||||]@@@@@@| || g@@@@@@@@@@p ,@@@@@&@@@@@@|#L !|
%@@@@@@@@@k|||||||||||||
`||||||||||||]@@@@@@ `||$@@@@N@@@@@@&@$@@$@@@@@@@@@@@@@ ||
]%@@@@@@@@H|||||||||||||
`||||||||||||]@@@@@@ ^@@@@@NM@@@@@@@@@ |@@@@@@@@@@@@@@''`
%@@@@@@%%||||||||||||||
||||||||||||%@@@@@@ ]B@@@@@@|&@@@@@@@M$@@@@@@@@@/@@@@@
]@@@@@@@%!!!|||||||||||
'|||||||||||]@@@@@@o @@@@@@@@@|N@@@@@ @@@@@@@@@|@@@@@@ ]@@@@@@@%
```'|||||||||
'|||||||||||]@@@@@@@ ]@@@@@@@@@@]%@N@ Q@@@@%@[]@@@@@@N p@@@@@@%M
`|||||||
`||||||||||||]@@@@@@@; %N@@@@@@@@@@@@Lj@@gg@@@@@@N@@@N )@@@@@@@@F '||||||
`|||||||||||||]%@@@@@@@r %@@@@@@@@@@@@@@@@@@@@@@@@@@@K ]@@@@@@@@h '`||||||
`||||||||||||||]@%N%N@@@gm,, j%@@@@@@@@@@@@@@@@@@@@@%h ;p@@@@@@@@@F `||||||
`|||||||||||||||j%@@@@@@@@@p".. ,,;g@@@@@@@@@@*" `||||||
`||||||||||||||||||]%@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@k@]N" '||||||
`|||||||||||||||'``'"@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@**'``` |||||||
`||||||||||||||'|` '*@@@@@@@@@@@@@@@@@@@`` y||||||
`'||||||||||||'` ''"**||||||||||| j|||||||
``|||||||||||` `'`'|jk* ,j||||||||
`'||||||||||| '` ;p||||||||||
``||||||||||' `'*j||||||
``||||||||||| ||
___________________________________________________________________________________________________________________________________________________________*/
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace std;
using namespace __gnu_pbds;
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define mellow \
ios_base::sync_with_stdio(0); \
cin.tie(0)
#define qa \
cout << "------------" \
<< "\n"
#define fo(i, n) for (ll i = 0; i < n; i++)
#define Fo(i, k, n) for (ll i = k; i < n; i++)
#define ll long long
#define deb(x) cout << #x << "=" << x << endl
#define deb2(x, y) cout << #x << "=" << x << "," << #y << "=" << y << endl
#define debV(arr) \
cout << #arr << ": "; \
for (int qwe = 0; qwe < arr.size(); qwe++) \
cout << arr[qwe] << " "; \
cout << "\n"
#define debVV(arr) \
for (int ewq = 0; ewq < arr.size(); ewq++) { \
for (int ews = 0; ews < arr[ewq].size(); ews++) \
cout << arr[ewq][ews] << " "; \
cout << endl; \
} \
cout << endl;
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define all(x) x.begin(), x.end()
#define clr(x) memset(x, 0, sizeof(x))
#define sortall(x) sort(all(x))
#define trav(it, a) for (auto it = a.begin(); it != a.end(); it++)
#define pres(a, x) ((a).find(x) != (a).end())
#define PI 3.1415926535897932384626
#define endl "\n"
#define mod 1000000007
#define sz(x) (int)x.size()
#define vvl(name, rowsize, colsize) \
vector<vector<ll>> name((rowsize), vector<ll>(colsize));
#define vvl0(name, rowsize, colsize) \
vector<vector<ll>> name((rowsize), vector<ll>(colsize, 0));
#define meme(ssss) \
for (int zasi = 0; zasi < ssss.size(); zasi++) { \
for (int zasj = 0; zasj < ssss[zasi].size(); zasj++) \
ssss[zasi][zasj] = 0; \
}
#define LLM LONG_LONG_MAX
typedef tree<ll, null_type, less<ll>, rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<string> vs;
vi X = {0, -1, 0, 1};
vi Y = {-1, 0, 1, 0};
ll powerFast(ll a, ll b) {
if (b == 0)
return 1;
ll c = powerFast(a, b / 2);
if (b % 2 == 0)
return ((c % mod) * (c % mod)) % mod;
else
return ((((c % mod) * (c % mod)) % mod) * a) % mod;
}
ll powerFast2(ll a, ll b) {
if (b == 0)
return 1;
ll c = powerFast(a, b / 2);
if (b % 2 == 0)
return ((c) * (c));
else
return ((((c) * (c))) * a);
}
// add custom hash infront of unordered_map and gp_hash_table
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
//____________________________________________________________________________________________________________________________________________________________
ll n = 0;
ll dp(vector<vll> &a, vector<vll> &arrDp, ll index, ll flag) {
if (index == n)
return 0;
ll ans = 0;
if (arrDp[index][flag] != -1)
return arrDp[index][flag];
if (index == 0) {
ans = max(a[index][0] + dp(a, arrDp, index + 1, 0), ans);
ans = max(a[index][1] + dp(a, arrDp, index + 1, 1), ans);
ans = max(a[index][2] + dp(a, arrDp, index + 1, 2), ans);
} else {
if (flag == 0) {
ans = max(ans, a[index][1] + dp(a, arrDp, index + 1, 1));
ans = max(ans, a[index][2] + dp(a, arrDp, index + 1, 2));
}
if (flag == 1) {
ans = max(ans, a[index][0] + dp(a, arrDp, index + 1, 0));
ans = max(ans, a[index][2] + dp(a, arrDp, index + 1, 2));
}
if (flag == 2) {
ans = max(ans, a[index][0] + dp(a, arrDp, index + 1, 0));
ans = max(ans, a[index][1] + dp(a, arrDp, index + 1, 1));
}
}
arrDp[index][flag] = ans;
return ans;
}
ll compute() {
cin >> n;
vector<vll> a(n, vll(3, 0));
vector<vll> arrDp(n, vll(3, -1));
for (int i = 0; i < n; i++) {
for (int j = 0; j < a[i].size(); j++)
cin >> a[i][j];
}
return dp(a, arrDp, 0, 0);
}
int main() {
mellow;
ll TESTS = 1;
// cin>>TESTS;
while (TESTS--) {
cout << compute() << "\n";
// compute();
}
return 0;
} | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 962,971 | 962,972 | u110320209 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int a[n][3];
for (int i = 0; i < n; i++) {
cin >> a[i][0];
cin >> a[i][1];
cin >> a[i][2];
}
for (int i = 1; i < n; i++) {
a[i][0] += max(a[i - 1][1], a[i - 1][2]);
a[i][1] += max(a[i - 1][0], a[i - 1][2]);
a[i][2] += max(a[i - 1][1], a[i - 1][0]);
}
cout << max(a[n - 1][0], max(a[n - 1][1], a[n - 1][2])) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n][3];
for (int i = 0; i < n; i++) {
cin >> a[i][0];
cin >> a[i][1];
cin >> a[i][2];
}
for (int i = 1; i < n; i++) {
a[i][0] += max(a[i - 1][1], a[i - 1][2]);
a[i][1] += max(a[i - 1][0], a[i - 1][2]);
a[i][2] += max(a[i - 1][1], a[i - 1][0]);
// cout<<a[i][0]<<" "<<a[i][1]<<" "<<a[i][2]<<endl;
}
cout << max(a[n - 1][0], max(a[n - 1][1], a[n - 1][2])) << endl;
return 0;
} | [] | 962,981 | 962,982 | u691174533 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c;
cin >> n;
int A = 0, B = 0, C = 0;
for (int i = 0; i < n; i++) {
cin >> a >> b >> c;
a += max(B, C);
b += max(A, C);
c += max(A, B);
A = a;
B = b;
C = c;
}
cout << max(A, (B, C)) << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c;
cin >> n;
int A = 0, B = 0, C = 0;
for (int i = 0; i < n; i++) {
cin >> a >> b >> c;
a += max(B, C);
b += max(A, C);
c += max(A, B);
A = a;
B = b;
C = c;
}
cout << max(A, max(B, C)) << endl;
}
| [
"call.add",
"call.arguments.change"
] | 962,985 | 962,986 | u681283552 | cpp |
p03162 | /*
Competitive programming template
Author: Aswin Sampath
*/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef vector<ll> vl;
typedef vector<int> vi;
typedef priority_queue<ll, vl, greater<ll>()> pq_ll_min;
typedef priority_queue<ll> pq_ll_max;
typedef stack<ll> s;
typedef queue<ll> q;
#define pi 3.141592653589793
#define PI acos(-1.0)
#define space " "
#define endl '\n'
#define F first
#define S second
#define pb(x) push_back(x)
#define mp(a, b) make_pair(a, b)
#define FAST \
{ \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0); \
}
#define testcase \
ll t; \
cin >> t; \
while (t--)
#define dbxstl(x) \
{ \
for (auto ele : x) \
cout << ele << space; \
cout << endl; \
}
#define dbxval(x) \
{ cout << x << endl; }
const ll INF = 1e18 + 7;
const ll MOD = 1e9 + 7;
void solve() { printf("Hello\n"); }
int main(int argc, char const *argv[]) {
ll n;
cin >> n;
vector<ll> dp(3, 0);
for (int days = 0; days < n; days++) {
vector<ll> temp(3, 0);
vector<ll> params(3);
for (int i = 0; i < 3; i++) {
cin >> params[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
if (i != j) {
temp[j] = max(temp[j], dp[i] + params[j]);
}
}
}
dp = temp;
}
ll ans = max({dp[0], dp[1], dp[2]});
cout << ans << endl;
return 0;
}
| /*
Competitive programming template
Author: Aswin Sampath
*/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef vector<ll> vl;
typedef vector<int> vi;
typedef priority_queue<ll, vl, greater<ll>()> pq_ll_min;
typedef priority_queue<ll> pq_ll_max;
typedef stack<ll> s;
typedef queue<ll> q;
#define pi 3.141592653589793
#define PI acos(-1.0)
#define space " "
#define endl '\n'
#define F first
#define S second
#define pb(x) push_back(x)
#define mp(a, b) make_pair(a, b)
#define FAST \
{ \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0); \
}
#define testcase \
ll t; \
cin >> t; \
while (t--)
#define dbxstl(x) \
{ \
for (auto ele : x) \
cout << ele << space; \
cout << endl; \
}
#define dbxval(x) \
{ cout << x << endl; }
const ll INF = 1e18 + 7;
const ll MOD = 1e9 + 7;
void solve() { printf("Hello\n"); }
int main(int argc, char const *argv[]) {
ll n;
cin >> n;
vector<ll> dp(3, 0);
for (int days = 0; days < n; days++) {
vector<ll> temp(3, 0);
vector<ll> params(3);
for (int i = 0; i < 3; i++) {
cin >> params[i];
}
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (i != j) {
temp[j] = max(temp[j], dp[i] + params[j]);
}
}
}
dp = temp;
}
ll ans = max({dp[0], dp[1], dp[2]});
cout << ans << endl;
return 0;
}
| [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 962,993 | 962,994 | u968826463 | cpp |
p03162 | /*
Competitive programming template
Author: Aswin Sampath
*/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef vector<ll> vl;
typedef vector<int> vi;
typedef priority_queue<ll, vl, greater<ll>()> pq_ll_min;
typedef priority_queue<ll> pq_ll_max;
typedef stack<ll> s;
typedef queue<ll> q;
#define pi 3.141592653589793
#define PI acos(-1.0)
#define space " "
#define endl '\n'
#define F first
#define S second
#define pb(x) push_back(x)
#define mp(a, b) make_pair(a, b)
#define FAST \
{ \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0); \
}
#define testcase \
ll t; \
cin >> t; \
while (t--)
#define dbxstl(x) \
{ \
for (auto ele : x) \
cout << ele << space; \
cout << endl; \
}
#define dbxval(x) \
{ cout << x << endl; }
const ll INF = 1e18 + 7;
const ll MOD = 1e9 + 7;
void solve() { printf("Hello\n"); }
int main(int argc, char const *argv[]) {
ll n;
cin >> n;
vector<ll> dp(3, 0);
for (int days = 0; days < n; days++) {
vector<ll> temp(3);
vector<ll> params(3);
for (int i = 0; i < 3; i++) {
cin >> params[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
if (i != j) {
temp[j] = max(temp[j], dp[i] + params[i]);
}
}
}
dp = temp;
}
ll ans = max({dp[0], dp[1], dp[2]});
cout << ans << endl;
return 0;
}
| /*
Competitive programming template
Author: Aswin Sampath
*/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef vector<ll> vl;
typedef vector<int> vi;
typedef priority_queue<ll, vl, greater<ll>()> pq_ll_min;
typedef priority_queue<ll> pq_ll_max;
typedef stack<ll> s;
typedef queue<ll> q;
#define pi 3.141592653589793
#define PI acos(-1.0)
#define space " "
#define endl '\n'
#define F first
#define S second
#define pb(x) push_back(x)
#define mp(a, b) make_pair(a, b)
#define FAST \
{ \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0); \
}
#define testcase \
ll t; \
cin >> t; \
while (t--)
#define dbxstl(x) \
{ \
for (auto ele : x) \
cout << ele << space; \
cout << endl; \
}
#define dbxval(x) \
{ cout << x << endl; }
const ll INF = 1e18 + 7;
const ll MOD = 1e9 + 7;
void solve() { printf("Hello\n"); }
int main(int argc, char const *argv[]) {
ll n;
cin >> n;
vector<ll> dp(3, 0);
for (int days = 0; days < n; days++) {
vector<ll> temp(3, 0);
vector<ll> params(3);
for (int i = 0; i < 3; i++) {
cin >> params[i];
}
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (i != j) {
temp[j] = max(temp[j], dp[i] + params[j]);
}
}
}
dp = temp;
}
ll ans = max({dp[0], dp[1], dp[2]});
cout << ans << endl;
return 0;
}
| [
"call.arguments.add",
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change"
] | 962,995 | 962,994 | u968826463 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define INF 2000000000
struct plan {
int a, b, c;
plan(int a = 0, int b = 0, int c = 0) : a(a), b(b), c(c) {}
};
int main() {
int n;
cin >> n;
vector<plan> p(n);
int a, b, c;
for (int i = 0; i < n; i++) {
cin >> a >> b >> c;
p[i].a = a;
p[i].b = b;
p[i].c = c;
}
vector<vector<int>> dp(n + 1, vector<int>(3, -1 * INF));
dp[0][0] = dp[0][1] = dp[0][2] = 0;
for (int i = 0; i < n; i++) {
dp[i + 1][0] = max(dp[i + 1][0], max(dp[i][1] + p[i].a, dp[i][2] + p[i].a));
dp[i + 1][1] = max(dp[i + 1][0], max(dp[i][0] + p[i].b, dp[i][2] + p[i].b));
dp[i + 1][2] = max(dp[i + 1][0], max(dp[i][0] + p[i].c, dp[i][1] + p[i].c));
}
cout << max(dp[n][0], max(dp[n][1], dp[n][2])) << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define INF 2000000000
struct plan {
int a, b, c;
plan(int a = 0, int b = 0, int c = 0) : a(a), b(b), c(c) {}
};
int main() {
int n;
cin >> n;
vector<plan> p(n);
int a, b, c;
for (int i = 0; i < n; i++) {
cin >> a >> b >> c;
p[i].a = a;
p[i].b = b;
p[i].c = c;
}
vector<vector<int>> dp(n + 1, vector<int>(3, -1 * INF));
dp[0][0] = dp[0][1] = dp[0][2] = 0;
for (int i = 0; i < n; i++) {
dp[i + 1][0] = max(dp[i + 1][0], max(dp[i][1] + p[i].a, dp[i][2] + p[i].a));
dp[i + 1][1] = max(dp[i + 1][1], max(dp[i][0] + p[i].b, dp[i][2] + p[i].b));
dp[i + 1][2] = max(dp[i + 1][2], max(dp[i][0] + p[i].c, dp[i][1] + p[i].c));
}
cout << max(dp[n][0], max(dp[n][1], dp[n][2])) << endl;
} | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change"
] | 963,013 | 963,014 | u685233906 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> dp1(3);
for (int i = 0; i < n; ++i) {
vector<int> dp2(3, 0);
vector<int> c(3);
cin >> c[0] >> c[1] >> c[2];
for (int j = 0; j < 3; ++j) {
for (int k = 0; k < 3; ++k) {
if (i != j)
dp2[k] = max(dp2[k], dp1[j] + c[j]);
}
}
dp1 = dp2;
}
cout << max({dp1[0], dp1[1], dp1[2]});
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> dp1(3);
for (int i = 0; i < n; ++i) {
vector<int> dp2(3, 0);
vector<int> c(3);
cin >> c[0] >> c[1] >> c[2];
for (int j = 0; j < 3; ++j) {
for (int k = 0; k < 3; ++k) {
if (j != k)
dp2[k] = max(dp2[k], dp1[j] + c[j]);
}
}
dp1 = dp2;
}
cout << max({dp1[0], dp1[1], dp1[2]});
return 0;
}
| [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change"
] | 963,017 | 963,018 | u473494697 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int dp[3], m[3];
int main() {
// ios_base::sync_with_stdio(false);
// cin.tie(NULL);
int n;
cin >> n;
cin >> dp[0] >> dp[1] >> dp[2];
for (int i = 0; i < n; i++) {
cin >> m[0] >> m[1] >> m[2];
m[0] += max(dp[1], dp[2]);
m[1] += max(dp[0], dp[2]);
m[2] += max(dp[1], dp[0]);
dp[0] = m[0];
dp[1] = m[1];
dp[2] = m[2];
}
printf("%d", max(dp[0], max(dp[1], dp[2])));
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int dp[3], m[3];
int main() {
// ios_base::sync_with_stdio(false);
// cin.tie(NULL);
int n;
cin >> n;
cin >> dp[0] >> dp[1] >> dp[2];
for (int i = 1; i < n; i++) {
cin >> m[0] >> m[1] >> m[2];
m[0] += max(dp[1], dp[2]);
m[1] += max(dp[0], dp[2]);
m[2] += max(dp[1], dp[0]);
dp[0] = m[0];
dp[1] = m[1];
dp[2] = m[2];
}
printf("%d", max(dp[0], max(dp[1], dp[2])));
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 963,019 | 963,020 | u265356851 | cpp |
p03162 | #include <algorithm>
#include <bits/stdc++.h>
#include <ctype.h>
#include <math.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
using namespace std;
#define pb push_back
#define S second
#define F first
#define f(i, n) for (ll i = 0; i < n; i++)
#define fast \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define vi vector<int>
#define pii pair<int, int>
#define CASES \
ll t; \
cin >> t; \
while (t--)
typedef long long ll;
typedef unsigned long long ull;
int main() {
fast;
ll n;
cin >> n;
ll a[n], b[n], c[n];
ll dp1[n], dp2[n], dp3[n];
f(i, n) cin >> a[i] >> b[i] >> c[i];
dp1[0] = a[0];
dp2[0] = b[0];
dp3[0] = c[0];
for (ll i = 1; i < n; i++) {
dp1[i] = max(dp2[i - 1], dp3[i - 1]) + a[i];
dp2[i] = max(dp1[i - 1], dp3[i - 1]) + b[i];
dp3[i] = max(dp2[i - 1], dp1[i - 1]) + c[i];
}
ll ans;
ans = max(dp1[n - 1], max(dp2[n - 1], dp2[n - 1]));
cout << ans;
return 0;
} | #include <algorithm>
#include <bits/stdc++.h>
#include <ctype.h>
#include <math.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
using namespace std;
#define pb push_back
#define S second
#define F first
#define f(i, n) for (ll i = 0; i < n; i++)
#define fast \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define vi vector<int>
#define pii pair<int, int>
#define CASES \
ll t; \
cin >> t; \
while (t--)
typedef long long ll;
typedef unsigned long long ull;
int main() {
fast;
ll n;
cin >> n;
ll a[n], b[n], c[n];
ll dp1[n], dp2[n], dp3[n];
f(i, n) cin >> a[i] >> b[i] >> c[i];
dp1[0] = a[0];
dp2[0] = b[0];
dp3[0] = c[0];
for (ll i = 1; i < n; i++) {
dp1[i] = max(dp2[i - 1], dp3[i - 1]) + a[i];
dp2[i] = max(dp1[i - 1], dp3[i - 1]) + b[i];
dp3[i] = max(dp2[i - 1], dp1[i - 1]) + c[i];
}
ll ans;
ans = max(dp1[n - 1], max(dp2[n - 1], dp3[n - 1]));
cout << ans;
return 0;
} | [
"assignment.value.change",
"identifier.change",
"call.arguments.change"
] | 963,027 | 963,028 | u331842396 | cpp |
p03162 | #include <bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp>
#define cases \
long long test; \
cin >> test; \
while (test--)
#define f_io \
ios::sync_with_stdio(false); \
cin.tie(0)
#define foi(a, n) for (long long i = a; i < n; i++)
#define foj(a, n) for (long long j = a; j < n; j++)
#define fok(a, n) for (long long k = a; k < n; k++)
#define ll long long
#define MOD 1000000007
#define INF 1000000000
using namespace std;
// using namespace __gnu_pbds;
// typedef tree<ll,null_type,less<ll>,rb_tree_tag,
// tree_order_statistics_node_update> indexed_set;
int main() {
f_io;
int n, num = 0;
cin >> n;
long long a[n], b[n], c[n], dp[n + 1][3];
foi(0, n) { cin >> a[i] >> b[i] >> c[i]; }
memset(dp, 0, sizeof(dp));
foi(0, n) {
dp[i + 1][0] = max(dp[i + 1][0], max(dp[i][1], dp[i][2]) + a[i]);
dp[i + 1][1] = max(dp[i + 1][1], max(dp[i][1], dp[i][0]) + b[i]);
dp[i + 1][2] = max(dp[i + 1][2], max(dp[i][1], dp[i][0]) + c[i]);
}
cout << max(dp[n][0], max(dp[n][1], dp[n][2]));
} | #include <bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp>
#define cases \
long long test; \
cin >> test; \
while (test--)
#define f_io \
ios::sync_with_stdio(false); \
cin.tie(0)
#define foi(a, n) for (long long i = a; i < n; i++)
#define foj(a, n) for (long long j = a; j < n; j++)
#define fok(a, n) for (long long k = a; k < n; k++)
#define ll long long
#define MOD 1000000007
#define INF 1000000000
using namespace std;
// using namespace __gnu_pbds;
// typedef tree<ll,null_type,less<ll>,rb_tree_tag,
// tree_order_statistics_node_update> indexed_set;
int main() {
f_io;
int n, num = 0;
cin >> n;
long long a[n], b[n], c[n], dp[n + 1][3];
foi(0, n) { cin >> a[i] >> b[i] >> c[i]; }
memset(dp, 0, sizeof(dp));
foi(0, n) {
dp[i + 1][0] = max(dp[i + 1][0], max(dp[i][1], dp[i][2]) + a[i]);
dp[i + 1][1] = max(dp[i + 1][1], max(dp[i][2], dp[i][0]) + b[i]);
dp[i + 1][2] = max(dp[i + 1][2], max(dp[i][1], dp[i][0]) + c[i]);
}
cout << max(dp[n][0], max(dp[n][1], dp[n][2]));
} | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 963,031 | 963,032 | u337755352 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
struct activity {
int A, B, C;
};
int solve(vector<activity> arr, int n) {
int dp[n][3];
dp[0][0] = arr[0].A;
dp[0][1] = arr[0].B;
dp[0][2] = arr[0].C;
for (int i = 1; i < n; i++) {
dp[i][0] = arr[i].A + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = arr[i].B + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][1] = arr[i].C + max(dp[i - 1][0], dp[i - 1][1]);
}
return (max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2])));
}
int main() {
int n;
cin >> n;
vector<activity> arr(n);
for (int i = 0; i < n; i++) {
cin >> arr[i].A;
cin >> arr[i].B;
cin >> arr[i].C;
}
cout << solve(arr, n);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
struct activity {
int A, B, C;
};
int solve(vector<activity> arr, int n) {
int dp[n][3];
dp[0][0] = arr[0].A;
dp[0][1] = arr[0].B;
dp[0][2] = arr[0].C;
for (int i = 1; i < n; i++) {
dp[i][0] = arr[i].A + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = arr[i].B + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = arr[i].C + max(dp[i - 1][0], dp[i - 1][1]);
}
return (max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2])));
}
int main() {
int n;
cin >> n;
vector<activity> arr(n);
for (int i = 0; i < n; i++) {
cin >> arr[i].A;
cin >> arr[i].B;
cin >> arr[i].C;
}
cout << solve(arr, n);
return 0;
} | [
"literal.number.change",
"assignment.variable.change",
"variable_access.subscript.index.change"
] | 963,033 | 963,034 | u678649976 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n][3];
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
cin >> a[i][j];
}
}
int dp[n][3] = {0};
for (int i = 0; i < 3; i++)
dp[0][i] = a[0][i];
for (int i = 1; i < n; i++) {
for (int j = 0; j < 3; j++) {
if (j == 0)
dp[i][j] = (a[i][j] + max(dp[i - 1][j + 1], dp[i - 1][j + 2]));
else if (j == 1)
dp[i][j] = (a[i][j] + max(dp[i - 1][j + 1], dp[i - 1][j + 1]));
else if (j == 2)
dp[i][j] = (a[i][j] + max(dp[i - 1][j - 1], dp[i - 1][j - 2]));
}
}
int m = -1;
for (int i = 0; i < 3; i++) {
m = max(m, dp[n - 1][i]);
}
cout << m << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n][3];
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
cin >> a[i][j];
}
}
int dp[n][3] = {0};
for (int i = 0; i < 3; i++)
dp[0][i] = a[0][i];
for (int i = 1; i < n; i++) {
for (int j = 0; j < 3; j++) {
if (j == 0)
dp[i][j] = (a[i][j] + max(dp[i - 1][j + 1], dp[i - 1][j + 2]));
if (j == 1)
dp[i][j] = (a[i][j] + max(dp[i - 1][j - 1], dp[i - 1][j + 1]));
if (j == 2)
dp[i][j] = (a[i][j] + max(dp[i - 1][j - 1], dp[i - 1][j - 2]));
}
}
int m = -1;
for (int i = 0; i < 3; i++) {
m = max(m, dp[n - 1][i]);
}
cout << m << endl;
} | [
"control_flow.branch.if.replace.add",
"control_flow.branch.else_if.replace.remove",
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 963,035 | 963,036 | u675040086 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<vector<int>> v(n + 1);
int x, y, z;
for (int i = 1; i <= n; i++) {
cin >> x >> y >> z;
v[i].push_back(x);
v[i].push_back(y);
v[i].push_back(z);
}
int dp[n + 1][3];
dp[0][0] = dp[0][1] = dp[0][2] = 0;
for (int i = 1; i < n; i++) {
dp[i][0] = v[i][0] + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = v[i][1] + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = v[i][2] + max(dp[i - 1][0], dp[i - 1][1]);
}
cout << max(max(dp[n][0], dp[n][1]), dp[n][2]);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<vector<int>> v(n + 1);
int x, y, z;
for (int i = 1; i <= n; i++) {
cin >> x >> y >> z;
v[i].push_back(x);
v[i].push_back(y);
v[i].push_back(z);
}
int dp[n + 1][3];
dp[0][0] = dp[0][1] = dp[0][2] = 0;
for (int i = 1; i <= n; i++) {
dp[i][0] = v[i][0] + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = v[i][1] + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = v[i][2] + max(dp[i - 1][0], dp[i - 1][1]);
}
cout << max(max(dp[n][0], dp[n][1]), dp[n][2]);
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 963,041 | 963,042 | u702703568 | cpp |
p03162 | #include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<vector<ll>> count;
for (int i = 0; i < n; i++) {
vector<ll> add(3);
count.push_back(add);
}
int a, b, c;
cin >> a >> b >> c;
count[0][0] = a;
count[0][1] = b;
count[0][2] = c;
for (int i = 1; i < n; i++) {
cin >> a >> b >> c;
count[i][0] = a + max(count[i - 1][1], count[i - 1][2]);
count[i][1] = b + max(count[i - 1][0], count[i - 1][2]);
count[i][2] = c + max(count[i - 1][1], count[i - 1][1]);
}
ll ans = count[n - 1][0];
if (ans < count[n - 1][1]) {
ans = count[n - 1][1];
}
if (ans < count[n - 1][2]) {
ans = count[n - 1][2];
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<vector<ll>> count;
for (int i = 0; i < n; i++) {
vector<ll> add(3);
count.push_back(add);
}
int a, b, c;
cin >> a >> b >> c;
count[0][0] = a;
count[0][1] = b;
count[0][2] = c;
for (int i = 1; i < n; i++) {
cin >> a >> b >> c;
count[i][0] = a + max(count[i - 1][1], count[i - 1][2]);
count[i][1] = b + max(count[i - 1][0], count[i - 1][2]);
count[i][2] = c + max(count[i - 1][0], count[i - 1][1]);
}
ll ans = count[n - 1][0];
if (ans < count[n - 1][1]) {
ans = count[n - 1][1];
}
if (ans < count[n - 1][2]) {
ans = count[n - 1][2];
}
cout << ans << endl;
return 0;
}
| [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 963,049 | 963,050 | u274420084 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const int INF = 1145141919;
const long long INFL = 1LL << 60;
int main() {
int n;
cin >> n;
int a[110000], b[110000], c[110000];
int dp[110000][3] = {};
for (int i = 0; i < n; ++i) {
cin >> a[i] >> b[i] >> c[i];
}
dp[0][0] = a[0];
dp[0][1] = b[0];
dp[0][2] = c[0];
for (int i = 1; i < n; ++i) {
dp[i][0] = max(dp[i - 1][1] + b[i], dp[i - 1][2] + c[i]);
dp[i][1] = max(dp[i - 1][2] + c[i], dp[i - 1][0] + a[i]);
dp[i][2] = max(dp[i - 1][0] + a[i], dp[i - 1][1] + b[i]);
}
cout << max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2])) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const int INF = 1145141919;
const long long INFL = 1LL << 60;
int main() {
int n;
cin >> n;
int a[110000], b[110000], c[110000];
int dp[110000][3] = {};
for (int i = 0; i < n; ++i) {
cin >> a[i] >> b[i] >> c[i];
}
dp[0][0] = a[0];
dp[0][1] = b[0];
dp[0][2] = c[0];
for (int i = 1; i < n; ++i) {
dp[i][0] = max(dp[i - 1][1] + a[i], dp[i - 1][2] + a[i]);
dp[i][1] = max(dp[i - 1][2] + b[i], dp[i - 1][0] + b[i]);
dp[i][2] = max(dp[i - 1][0] + c[i], dp[i - 1][1] + c[i]);
}
cout << max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2])) << endl;
return 0;
} | [
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 963,055 | 963,056 | u330131083 | cpp |
p03162 | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <complex>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
#define MOD 1000000007
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<int> vi;
typedef vector<vl> vvl;
typedef vector<vi> vvi;
typedef vector<string> vs;
typedef pair<ll, ll> pll;
typedef pair<int, int> pi;
typedef vector<pll> vpl;
typedef vector<pi> vpi;
typedef vector<vs> vvs;
typedef vector<pll> vvpl;
typedef vector<vpi> vvpi;
typedef queue<ll> ql;
typedef queue<int> qi;
typedef queue<pll> qpl;
typedef queue<pi> qpi;
template <typename T> void printv(const vector<T> &v) {
for (int i = 0; i < v.size(); ++i) {
printf("[%d] %d\n", i, v[i]);
}
}
template <typename T> void printvv(const vector<T> &vv) {
for (int i = 0; i < vv.size(); ++i) {
for (int j = 0; j < vv[i].size(); ++j) {
printf("[%d][%d] %d\n", i, j, vv[i][j]);
}
}
}
template <typename T, typename U> void printp(const pair<T, U> &p) {
cout << p.first << " " << p.second << endl;
}
template <typename T> void printvp(const vector<pair<T, T>> &vp) {
for (int i = 0; i < vp.size(); ++i) {
printf("[%d] %d, %d\n", vp[i].first, vp[i].second);
}
}
template <typename T> void printvvp(const vector<vector<pair<T, T>>> &vvp) {
for (int i = 0; i < vvp.size(); ++i) {
for (int j = 0; j < vvp[i].size(); ++j) {
printf("[%d][%d] %d, %d\n", i, j, vvp[i][j].first, vvp[i][j].second);
}
}
}
int main() {
int N;
cin >> N;
vvi a(N, vi(3));
for (int i = 0; i < N; ++i)
for (int j = 0; j < 3; ++j)
cin >> a[i][j];
vvi dp(N + 1, vi(3));
for (int i = 0; i < N; ++i) {
for (int j = 0; j < 3; ++j) {
for (int k = 0; k < 3; ++k) {
if (j == k)
continue;
dp[i + 1][k] = max(dp[i + 1][k], dp[i][j] + a[i][k]);
}
}
}
printvv(dp);
cout << max(max(dp[N][0], dp[N][1]), dp[N][2]) << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <complex>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
#define MOD 1000000007
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<int> vi;
typedef vector<vl> vvl;
typedef vector<vi> vvi;
typedef vector<string> vs;
typedef pair<ll, ll> pll;
typedef pair<int, int> pi;
typedef vector<pll> vpl;
typedef vector<pi> vpi;
typedef vector<vs> vvs;
typedef vector<pll> vvpl;
typedef vector<vpi> vvpi;
typedef queue<ll> ql;
typedef queue<int> qi;
typedef queue<pll> qpl;
typedef queue<pi> qpi;
template <typename T> void printv(const vector<T> &v) {
for (int i = 0; i < v.size(); ++i) {
printf("[%d] %d\n", i, v[i]);
}
}
template <typename T> void printvv(const vector<T> &vv) {
for (int i = 0; i < vv.size(); ++i) {
for (int j = 0; j < vv[i].size(); ++j) {
printf("[%d][%d] %d\n", i, j, vv[i][j]);
}
}
}
template <typename T, typename U> void printp(const pair<T, U> &p) {
cout << p.first << " " << p.second << endl;
}
template <typename T> void printvp(const vector<pair<T, T>> &vp) {
for (int i = 0; i < vp.size(); ++i) {
printf("[%d] %d, %d\n", vp[i].first, vp[i].second);
}
}
template <typename T> void printvvp(const vector<vector<pair<T, T>>> &vvp) {
for (int i = 0; i < vvp.size(); ++i) {
for (int j = 0; j < vvp[i].size(); ++j) {
printf("[%d][%d] %d, %d\n", i, j, vvp[i][j].first, vvp[i][j].second);
}
}
}
int main() {
int N;
cin >> N;
vvi a(N, vi(3));
for (int i = 0; i < N; ++i)
for (int j = 0; j < 3; ++j)
cin >> a[i][j];
vvi dp(N + 1, vi(3));
for (int i = 0; i < N; ++i) {
for (int j = 0; j < 3; ++j) {
for (int k = 0; k < 3; ++k) {
if (j == k)
continue;
dp[i + 1][k] = max(dp[i + 1][k], dp[i][j] + a[i][k]);
}
}
}
cout << max(max(dp[N][0], dp[N][1]), dp[N][2]) << endl;
return 0;
}
| [
"call.remove"
] | 963,058 | 963,059 | u381120152 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c;
cin >> n;
vector<vector<int>> inp(n, vector<int>(3));
for (int t = 0; t < n; t++) {
cin >> a >> b >> c;
inp[t][0] = a;
inp[t][1] = b;
inp[t][2] = c;
}
vector<vector<int>> dp(n, vector<int>(3));
dp[0][0] = inp[0][0];
dp[0][1] = inp[0][1];
dp[0][2] = inp[0][2];
for (int i = 1; i < n; i++) {
dp[i][0] = max(dp[i - 1][1], dp[i - 1][2]) + inp[i][0];
dp[i][1] = max(dp[i - 1][0], dp[i - 1][2]) + inp[i][1];
dp[i][2] = max(dp[i - 1][1], dp[i - 1][0]) + inp[i][2];
}
cout << max({dp[n][0], dp[n][1], dp[n][2]}) << '\n';
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c;
cin >> n;
vector<vector<int>> inp(n, vector<int>(3));
for (int t = 0; t < n; t++) {
cin >> a >> b >> c;
inp[t][0] = a;
inp[t][1] = b;
inp[t][2] = c;
}
vector<vector<int>> dp(n, vector<int>(3));
dp[0][0] = inp[0][0];
dp[0][1] = inp[0][1];
dp[0][2] = inp[0][2];
for (int i = 1; i < n; i++) {
dp[i][0] = max(dp[i - 1][1], dp[i - 1][2]) + inp[i][0];
dp[i][1] = max(dp[i - 1][0], dp[i - 1][2]) + inp[i][1];
dp[i][2] = max(dp[i - 1][1], dp[i - 1][0]) + inp[i][2];
}
cout << max({dp[n - 1][0], dp[n - 1][1], dp[n - 1][2]}) << '\n';
} | [
"expression.operation.binary.add"
] | 963,064 | 963,065 | u456172074 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(3, 0);
for (int i = 0; i < n; i++) {
vector<int> d(3);
vector<int> vec(3, 0);
for (int w = 0; w < 3; w++)
cin >> d[w];
for (int i = 0; i < 0; i++) {
for (int j = 0; j < 3; j++) {
if (i != j)
vec[j] = max(vec[j], v[i] + d[j]);
}
}
v = vec;
}
cout << max({v[0], v[1], v[2]});
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(3, 0);
for (int i = 0; i < n; i++) {
vector<int> d(3);
vector<int> vec(3, 0);
for (int w = 0; w < 3; w++)
cin >> d[w];
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (i != j)
vec[j] = max(vec[j], v[i] + d[j]);
}
}
v = vec;
}
cout << max({v[0], v[1], v[2]});
return 0;
}
| [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 963,066 | 963,067 | u420978656 | cpp |
p03162 | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (n); i++)
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b)
a = b;
return true;
return false;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<vector<int>> a(n, vector<int>(3));
REP(i, n) REP(j, 3) cin >> a[i][j];
vector<vector<int>> dp(n + 1, vector<int>(3, 0));
REP(i, n) REP(j, 3) REP(k, 3) {
if (j == k)
continue;
chmax(dp[i + 1][j], dp[i][j] + a[i][k]);
}
int sum = 0;
REP(i, 3) chmax(sum, dp[n][i]);
cout << sum << '\n';
return 0;
} | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (n); i++)
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b)
a = b;
return true;
return false;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<vector<int>> a(n, vector<int>(3));
REP(i, n) REP(j, 3) cin >> a[i][j];
vector<vector<int>> dp(n + 1, vector<int>(3, 0));
REP(i, n) REP(j, 3) REP(k, 3) {
if (j == k)
continue;
chmax(dp[i + 1][k], dp[i][j] + a[i][k]);
}
int ans = 0;
REP(i, 3) chmax(ans, dp[n][i]);
cout << ans << '\n';
return 0;
} | [
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"variable_declaration.name.change",
"io.output.change"
] | 963,068 | 963,069 | u596385287 | cpp |
p03162 | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (n); i++)
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b)
a = b;
return true;
return false;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<vector<int>> a(n, vector<int>(3));
REP(i, n) REP(j, 3) cin >> a[i][j];
vector<vector<int>> dp(n + 1, vector<int>(3, 0));
REP(i, n) REP(j, 3) REP(k, 3) {
if (j == k)
continue;
chmax(dp[i + 1][j], dp[i][j] + a[i][k]);
}
int sum = 0;
REP(i, 3) chmax(sum, dp[n][i]);
cout << sum << '\n';
return 0;
} | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (n); i++)
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b)
a = b;
return true;
return false;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<vector<int>> a(n, vector<int>(3));
REP(i, n) REP(j, 3) cin >> a[i][j];
vector<vector<int>> dp(n + 1, vector<int>(3, 0));
REP(i, n) REP(j, 3) REP(k, 3) {
if (j == k)
continue;
chmax(dp[i + 1][k], dp[i][j] + a[i][k]);
}
int sum = 0;
REP(i, 3) chmax(sum, dp[n][i]);
cout << sum << '\n';
return 0;
} | [
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change"
] | 963,068 | 963,070 | u596385287 | cpp |
p03162 | // In The Name Of Allah //
#include <bits/stdc++.h>
#define pb emplace_back
#define inf (int)1e9
#define ff first
#define ss second
#define ll long long
#define sp(n) cout << setprecision(n) << fixed
#define hellcat ios::sync_with_stdio(0), cin.tie(0), cout.tie(0)
#define give(x) cout << #x << " " << x << endl
#define debug cout << "dddd" << '\n'
#define debarr(a, n) \
for (int i = 0; i < n; ++i) \
cout << a[i] << ' '; \
cout << endl
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops")
#pragma GCC optimize("no-stack-protector,fast-math")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
template <class S, class T> inline S smax(S &l, T r) {
return l = max(l, (S)r);
}
template <class S, class T> inline bool smin(S &l, T r) {
return l = min(l, (S)r);
}
const int MAXN = 1e5 + 10;
int a[MAXN][4];
ll dp[MAXN][4];
int32_t main() {
hellcat;
int n;
cin >> n;
for (int i = 0; i < n; ++i)
cin >> a[i][0] >> a[i][1] >> a[i][2];
dp[0][0] = a[0][0];
dp[0][1] = a[0][1];
dp[0][2] = a[0][2];
for (int i = 1; i < n; ++i) {
dp[i][0] = a[i][1] + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = a[i][1] + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = a[i][2] + max(dp[i - 1][0], dp[i - 1][1]);
}
n--;
cout << max({dp[n][0], dp[n][1], dp[n][2]}) << '\n';
return 0;
}
| // In The Name Of Allah //
#include <bits/stdc++.h>
#define pb emplace_back
#define inf (int)1e9
#define ff first
#define ss second
#define ll long long
#define sp(n) cout << setprecision(n) << fixed
#define hellcat ios::sync_with_stdio(0), cin.tie(0), cout.tie(0)
#define give(x) cout << #x << " " << x << endl
#define debug cout << "dddd" << '\n'
#define debarr(a, n) \
for (int i = 0; i < n; ++i) \
cout << a[i] << ' '; \
cout << endl
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops")
#pragma GCC optimize("no-stack-protector,fast-math")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
template <class S, class T> inline S smax(S &l, T r) {
return l = max(l, (S)r);
}
template <class S, class T> inline bool smin(S &l, T r) {
return l = min(l, (S)r);
}
const int MAXN = 1e5 + 10;
int a[MAXN][4];
ll dp[MAXN][4];
int32_t main() {
hellcat;
int n;
cin >> n;
for (int i = 0; i < n; ++i)
cin >> a[i][0] >> a[i][1] >> a[i][2];
dp[0][0] = a[0][0];
dp[0][1] = a[0][1];
dp[0][2] = a[0][2];
for (int i = 1; i < n; ++i) {
dp[i][0] = a[i][0] + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = a[i][1] + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = a[i][2] + max(dp[i - 1][0], dp[i - 1][1]);
}
n--;
cout << max({dp[n][0], dp[n][1], dp[n][2]}) << '\n';
return 0;
}
| [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 963,075 | 963,076 | u857968161 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define int long long int
struct action {
int a;
int b;
int c;
};
int bottom(action axn[], int n) {
int dp[n + 1][3] = {0};
dp[0][0] = axn[0].a;
dp[0][1] = axn[1].b;
dp[0][2] = axn[2].c;
for (int i = 1; i < n; i++) {
dp[i][0] = axn[i].a + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = axn[i].b + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = axn[i].c + max(dp[i - 1][0], dp[i - 1][1]);
}
return max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2]));
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
action axn[n];
for (int i = 0; i < n; i++) {
cin >> axn[i].a;
cin >> axn[i].b;
cin >> axn[i].c;
}
cout << bottom(axn, n);
}
// 7
// 6 7 8
// 8 8 3
// 2 5 2
// 7 8 6
// 4 6 8
// 2 3 4
// 7 5 1 | #include <bits/stdc++.h>
using namespace std;
#define int long long int
struct action {
int a;
int b;
int c;
};
int bottom(action axn[], int n) {
int dp[n + 1][3] = {0};
dp[0][0] = axn[0].a;
dp[0][1] = axn[0].b;
dp[0][2] = axn[0].c;
for (int i = 1; i < n; i++) {
dp[i][0] = axn[i].a + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = axn[i].b + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = axn[i].c + max(dp[i - 1][0], dp[i - 1][1]);
}
return max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2]));
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
action axn[n];
for (int i = 0; i < n; i++) {
cin >> axn[i].a;
cin >> axn[i].b;
cin >> axn[i].c;
}
cout << bottom(axn, n);
}
// 7
// 6 7 8
// 8 8 3
// 2 5 2
// 7 8 6
// 4 6 8
// 2 3 4
// 7 5 1 | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change"
] | 963,077 | 963,078 | u362998653 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int a[100005][4];
int dp[100005][4];
int n;
int f(int day, int game)
{
if (day == n)
return 0;
if (dp[day][game] != -1)
return dp[day][game];
int maxi = 0;
if (game == 0) {
maxi = max(maxi, a[day][1] + f(day + 1, 1));
maxi = max(maxi, a[day][2] + f(day + 1, 2));
maxi = max(maxi, a[day][3] + f(day + 1, 3));
} else if (game == 1) {
maxi = max(maxi, a[day][2] + f(day + 1, 2));
maxi = max(maxi, a[day][3] + f(day + 1, 3));
} else if (game == 2) {
maxi = max(maxi, a[day][1] + f(day + 1, 1));
maxi = max(maxi, a[day][3] + f(day + 1, 3));
} else if (game == 3) {
maxi = max(maxi, a[day][1] + f(day + 1, 1));
maxi = max(maxi, a[day][2] + f(day + 1, 1));
}
return dp[day][game] = maxi;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= 3; j++)
cin >> a[i][j];
}
memset(dp, -1, sizeof(dp));
cout << f(0, 0);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int a[100005][4];
int dp[100005][4];
int n;
int f(int day, int game)
{
if (day == n)
return 0;
if (dp[day][game] != -1)
return dp[day][game];
int maxi = 0;
if (game == 0) {
maxi = max(maxi, a[day][1] + f(day + 1, 1));
maxi = max(maxi, a[day][2] + f(day + 1, 2));
maxi = max(maxi, a[day][3] + f(day + 1, 3));
} else if (game == 1) {
maxi = max(maxi, a[day][2] + f(day + 1, 2));
maxi = max(maxi, a[day][3] + f(day + 1, 3));
} else if (game == 2) {
maxi = max(maxi, a[day][1] + f(day + 1, 1));
maxi = max(maxi, a[day][3] + f(day + 1, 3));
} else if (game == 3) {
maxi = max(maxi, a[day][1] + f(day + 1, 1));
maxi = max(maxi, a[day][2] + f(day + 1, 2));
}
return dp[day][game] = maxi;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= 3; j++) {
cin >> a[i][j];
}
}
memset(dp, -1, sizeof(dp));
cout << f(0, 0);
return 0;
} | [
"literal.number.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 963,079 | 963,080 | u653707087 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int a[100005][4];
int dp[100005][4];
int n;
int f(int day, int game)
{
if (day == n)
return 0;
if (dp[day][game] != -1)
return dp[day][game];
int maxi = 0;
if (game == 0) {
maxi = max(maxi, a[day][1] + f(day + 1, 1));
maxi = max(maxi, a[day][2] + f(day + 1, 2));
maxi = max(maxi, a[day][3] + f(day + 1, 3));
} else if (game == 1) {
maxi = max(maxi, a[day][2] + f(day + 1, 2));
maxi = max(maxi, a[day][3] + f(day + 1, 3));
} else if (game == 2) {
maxi = max(maxi, a[day][1] + f(day + 1, 1));
maxi = max(maxi, a[day][3] + f(day + 1, 3));
} else if (game == 3) {
maxi = max(maxi, a[day][1] + f(day + 1, 1));
maxi = max(maxi, a[day][2] + f(day + 1, 1));
}
return dp[day][game] = maxi;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= 3; j++)
cin >> a[i][j];
memset(dp, -1, sizeof(dp));
cout << f(0, 0);
return 0;
}
} | #include <bits/stdc++.h>
using namespace std;
int a[100005][4];
int dp[100005][4];
int n;
int f(int day, int game)
{
if (day == n)
return 0;
if (dp[day][game] != -1)
return dp[day][game];
int maxi = 0;
if (game == 0) {
maxi = max(maxi, a[day][1] + f(day + 1, 1));
maxi = max(maxi, a[day][2] + f(day + 1, 2));
maxi = max(maxi, a[day][3] + f(day + 1, 3));
} else if (game == 1) {
maxi = max(maxi, a[day][2] + f(day + 1, 2));
maxi = max(maxi, a[day][3] + f(day + 1, 3));
} else if (game == 2) {
maxi = max(maxi, a[day][1] + f(day + 1, 1));
maxi = max(maxi, a[day][3] + f(day + 1, 3));
} else if (game == 3) {
maxi = max(maxi, a[day][1] + f(day + 1, 1));
maxi = max(maxi, a[day][2] + f(day + 1, 2));
}
return dp[day][game] = maxi;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= 3; j++) {
cin >> a[i][j];
}
}
memset(dp, -1, sizeof(dp));
cout << f(0, 0);
return 0;
} | [
"literal.number.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 963,081 | 963,080 | u653707087 | cpp |
p03162 | // A B C D H F E I G K L M N P S O Q R J U Z Y X T V W
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
using namespace std;
#define ff first
#define ss second
#define int long long
#define pb push_back
#define mp make_pair
#define pq priority_queue<int>
#define pqs priority_queue<int, vector<int>, greater<int>>
#define setbits(x) __builtin_popcountll(x) // no of ones in setbit
#define zrobits(x) \
__builtin_ctzll(x) // 101000 here 3..no of 0 aftrer 1sr right one
#define mod 1000000007
#define inf 1e18
#define ps(x, y) fixed << setprecision(y) << x // ans upto 5 decimal place
#define mk(ar, n, type) type *arr = new type[n];
#define w(x) \
int x; \
cin >> x; \
while (x--)
int arr[1001][1001];
int dp[10000][10000];
int fn(int k, int i, int n) {
if (i == n) {
return 0;
}
if (dp[i][k] != -1) {
return dp[i][k];
}
int ans = 0;
for (int j = 0; j < 3; j++) {
if (j != k)
ans = max(ans, arr[i][j] + fn(j, i + 1, n));
}
return dp[i][k] = ans;
}
int32_t main() {
int n, k;
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
cin >> arr[i][j];
}
}
// int ans=0 ;
// for(int i=0 ; i<3 ; i++)
// {
// for(int a=0 ; a<n; a++)
// {
// for(int b=0 ; b<3; b++)
// {
// dp[a][b]=-1 ;
// }
// }
// int z=arr[0][i]+fn( i ,1, n ) ;
// ans=max(ans, z);
// }
// cout<<ans;
dp[0][0] = arr[0][0];
dp[0][1] = arr[0][1];
dp[0][2] = arr[0][2];
for (int i = 1; i < n; i++) {
for (int j = 0; j < 3; j++) {
int a = dp[i - 1][(j + 3 - 1) % 3];
int b = dp[i - 1][(j + 3 + 1) % 3];
int z = max(a, b);
dp[i][j] = arr[i][j] + z;
}
}
// for(int i=0 ; i<n; i++)
// {
// for(int j=0 ; j<3; j++)
// {
// cout<<dp[i][j]<<" ";
// }
// cout<<endl ;
// }
int ans = max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2]));
cout << ans;
} | // A B C D H F E I G K L M N P S O Q R J U Z Y X T V W
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
using namespace std;
#define ff first
#define ss second
#define int long long
#define pb push_back
#define mp make_pair
#define pq priority_queue<int>
#define pqs priority_queue<int, vector<int>, greater<int>>
#define setbits(x) __builtin_popcountll(x) // no of ones in setbit
#define zrobits(x) \
__builtin_ctzll(x) // 101000 here 3..no of 0 aftrer 1sr right one
#define mod 1000000007
#define inf 1e18
#define ps(x, y) fixed << setprecision(y) << x // ans upto 5 decimal place
#define mk(ar, n, type) type *arr = new type[n];
#define w(x) \
int x; \
cin >> x; \
while (x--)
int arr[100001][4];
int dp[100001][4];
int fn(int k, int i, int n) {
if (i == n) {
return 0;
}
if (dp[i][k] != -1) {
return dp[i][k];
}
int ans = 0;
for (int j = 0; j < 3; j++) {
if (j != k)
ans = max(ans, arr[i][j] + fn(j, i + 1, n));
}
return dp[i][k] = ans;
}
int32_t main() {
int n, k;
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
cin >> arr[i][j];
}
}
// int ans=0 ;
// for(int i=0 ; i<3 ; i++)
// {
// for(int a=0 ; a<n; a++)
// {
// for(int b=0 ; b<3; b++)
// {
// dp[a][b]=-1 ;
// }
// }
// int z=arr[0][i]+fn( i ,1, n ) ;
// ans=max(ans, z);
// }
// cout<<ans;
dp[0][0] = arr[0][0];
dp[0][1] = arr[0][1];
dp[0][2] = arr[0][2];
for (int i = 1; i < n; i++) {
for (int j = 0; j < 3; j++) {
int a = dp[i - 1][(j + 3 - 1) % 3];
int b = dp[i - 1][(j + 3 + 1) % 3];
int z = max(a, b);
dp[i][j] = arr[i][j] + z;
}
}
// for(int i=0 ; i<n; i++)
// {
// for(int j=0 ; j<3; j++)
// {
// cout<<dp[i][j]<<" ";
// }
// cout<<endl ;
// }
int ans = max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2]));
cout << ans;
} | [
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 963,082 | 963,083 | u263294006 | cpp |
p03162 | #include <algorithm>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <queue>
#include <set>
#include <stdio.h>
#include <string.h>
#include <unordered_map>
#include <vector>
const int N = 1e5 + 1;
int f[N];
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int a[n], b[n], c[n];
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i] >> c[i];
}
int f[3][n];
// 0 - a
// 1 - b
// 2 - c
for (int i = 0; i < 3; i++) {
for (int j = 0; j < n; j++) {
f[i][j] = 0;
}
}
f[0][0] = a[0];
f[1][0] = b[0];
f[2][0] = c[0];
for (int i = 1; i <= n; i++) {
f[0][i] = max(f[1][i - 1], f[2][i - 1]) + a[i];
f[1][i] = max(f[2][i - 1], f[0][i - 1]) + b[i];
f[2][i] = max(f[1][i - 1], f[0][i - 1]) + c[i];
}
cout << max(max(f[0][n - 1], f[1][n - 1]), f[2][n - 1]) << "\n";
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <queue>
#include <set>
#include <stdio.h>
#include <string.h>
#include <unordered_map>
#include <vector>
const int N = 1e5 + 1;
int f[N];
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int a[n], b[n], c[n];
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i] >> c[i];
}
long long int f[3][n];
// 0 - a
// 1 - b
// 2 - c
for (int i = 0; i < 3; i++) {
for (int j = 0; j < n; j++) {
f[i][j] = 0;
}
}
f[0][0] = a[0];
f[1][0] = b[0];
f[2][0] = c[0];
for (int i = 1; i < n; i++) {
f[0][i] = max(f[1][i - 1], f[2][i - 1]) + a[i];
f[1][i] = max(f[2][i - 1], f[0][i - 1]) + b[i];
f[2][i] = max(f[1][i - 1], f[0][i - 1]) + c[i];
}
cout << max(max(f[0][n - 1], f[1][n - 1]), f[2][n - 1]) << "\n";
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 963,097 | 963,098 | u411957533 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double ld;
#define inf 1e18
#define for0(i, n) for (ll i = 0; i < (ll)(n); ++i) // 0 based indexing
#define for1(i, n) for (ll i = 1; i <= (ll)(n); ++i) // 1 based indexing
#define forc(i, l, r) \
for (ll i = (ll)(l); i <= (ll)(r); \
++i) // closed interver from l to r r inclusive
#define forr0(i, n) for (ll i = (ll)(n)-1; i >= 0; --i) // reverse 0 based.
#define forr1(i, n) for (ll i = (ll)(n); i >= 1; --i) // reverse 1 based
#define tc \
ll t; \
cin >> t; \
while (t--)
#define ff first
#define ss second
#define pb push_back
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll n;
cin >> n;
vector<ll> lin(3, 0);
vector<ll> rin(3, 0);
ll x, y, z;
cin >> lin[0] >> lin[1] >> lin[2];
for1(i, n - 1) {
cin >> x >> y >> z;
rin[0] = max(lin[1] + x, lin[2] + x);
rin[1] = max(lin[2] + y, lin[0] + y);
rin[2] = max(lin[0] + z, lin[1] + z);
for0(j, 3) { lin[j] = rin[j]; }
}
cout << max(max(rin[0], rin[1]), rin[2]) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double ld;
#define inf 1e18
#define for0(i, n) for (ll i = 0; i < (ll)(n); ++i) // 0 based indexing
#define for1(i, n) for (ll i = 1; i <= (ll)(n); ++i) // 1 based indexing
#define forc(i, l, r) \
for (ll i = (ll)(l); i <= (ll)(r); \
++i) // closed interver from l to r r inclusive
#define forr0(i, n) for (ll i = (ll)(n)-1; i >= 0; --i) // reverse 0 based.
#define forr1(i, n) for (ll i = (ll)(n); i >= 1; --i) // reverse 1 based
#define tc \
ll t; \
cin >> t; \
while (t--)
#define ff first
#define ss second
#define pb push_back
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll n;
cin >> n;
vector<ll> lin(3, 0);
vector<ll> rin(3, 0);
ll x, y, z;
cin >> lin[0] >> lin[1] >> lin[2];
for1(i, n - 1) {
cin >> x >> y >> z;
rin[0] = max(lin[1] + x, lin[2] + x);
rin[1] = max(lin[2] + y, lin[0] + y);
rin[2] = max(lin[0] + z, lin[1] + z);
for0(j, 3) { lin[j] = rin[j]; }
}
cout << max(max(lin[0], lin[1]), lin[2]) << endl;
return 0;
}
| [
"identifier.change",
"io.output.change"
] | 963,101 | 963,102 | u155580903 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n][3];
int i = 0;
while (i < n) {
cin >> a[i][0] >> a[i][1] >> a[i][2];
i++;
}
int dp1[n], dp2[n], dp3[n];
dp1[0] = a[0][0];
dp2[0] = a[0][1];
dp3[0] = a[0][2];
for (i = 1; i < n; i++) {
dp1[i] += a[i][0] + max(dp2[i - 1], dp3[i - 1]);
dp2[i] += a[i][1] + max(dp1[i - 1], dp3[i - 1]);
dp3[i] += a[i][2] + max(dp2[i - 1], dp1[i - 1]);
}
cout << max(dp1[n - 1], max(dp2[n - 1], dp3[n - 1])) << "\n";
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n][3];
int i = 0;
while (i < n) {
cin >> a[i][0] >> a[i][1] >> a[i][2];
i++;
}
int dp1[n], dp2[n], dp3[n];
dp1[0] = a[0][0];
dp2[0] = a[0][1];
dp3[0] = a[0][2];
for (i = 1; i < n; i++) {
dp1[i] = a[i][0] + max(dp2[i - 1], dp3[i - 1]);
dp2[i] = a[i][1] + max(dp1[i - 1], dp3[i - 1]);
dp3[i] = a[i][2] + max(dp2[i - 1], dp1[i - 1]);
}
cout << max(dp1[n - 1], max(dp2[n - 1], dp3[n - 1])) << "\n";
return 0;
} | [
"assignment.value.change"
] | 963,103 | 963,104 | u259468819 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
int arr[n][3];
for (int i = 0; i < n; i++) {
cin >> arr[i][0] >> arr[i][1] >> arr[i][2];
}
for (int i = 1; i < n; i++) {
arr[i][0] = arr[i][0] + max(arr[i - 1][1], arr[i - 1][2]);
arr[i][1] = arr[i][1] + max(arr[i - 1][0], arr[i - 1][2]);
arr[i][2] = arr[i][2] + max(arr[i - 1][0], arr[i - 1][1]);
}
cout << max({arr[n - 1][0], arr[n - 1][1], arr[n - 1][1]}) << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
int arr[n][3];
for (int i = 0; i < n; i++) {
cin >> arr[i][0] >> arr[i][1] >> arr[i][2];
}
for (int i = 1; i < n; i++) {
arr[i][0] = arr[i][0] + max(arr[i - 1][1], arr[i - 1][2]);
arr[i][1] = arr[i][1] + max(arr[i - 1][0], arr[i - 1][2]);
arr[i][2] = arr[i][2] + max(arr[i - 1][1], arr[i - 1][0]);
}
cout << max({arr[n - 1][0], arr[n - 1][1], arr[n - 1][2]}) << endl;
}
| [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change"
] | 963,113 | 963,114 | u988401048 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define mod 1000000007
#define pb push_back
#define pie 3.141592653589
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll i, n, n2, m, t, j, l, r, pos, mpos, f = 0, k, p, n1, z, q, x, y, x1, y1,
x2, y2, x3, y3, x4, y4;
cin >> n;
vector<ll> dp(3, 0);
while (n--) {
ll a[3];
for (i = 0; i < 3; i++)
cin >> a[i];
vector<ll> new_dp(3, 0);
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) {
if (i != j) {
new_dp[i] = max(new_dp[i], dp[i] + a[j]);
}
}
}
dp = new_dp;
}
x = max({dp[0], dp[1], dp[2]});
cout << x;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define mod 1000000007
#define pb push_back
#define pie 3.141592653589
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll i, n, n2, m, t, j, l, r, pos, mpos, f = 0, k, p, n1, z, q, x, y, x1, y1,
x2, y2, x3, y3, x4, y4;
cin >> n;
vector<ll> dp(3, 0);
while (n--) {
ll a[3];
for (i = 0; i < 3; i++)
cin >> a[i];
vector<ll> new_dp(3, 0);
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) {
if (i != j) {
new_dp[i] = max(new_dp[i], dp[j] + a[i]);
}
}
}
dp = new_dp;
}
x = max({dp[0], dp[1], dp[2]});
cout << x;
return 0;
} | [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 963,117 | 963,118 | u427140920 | cpp |
p03162 | /*
auth - @sportykush
*/
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
typedef long long int ll;
typedef long double ld;
typedef tree<ll, null_type, less<ll>, rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;
//#define mp make_pair
#define bug(v) cerr << #v << " = " << (v) << endl;
#define ERASE(x) x.erase(unique(x.begin(), x.end()), x.end())
#define pb emplace_back
#define vii vector<int>
#define vll vector<ll>
#define vpll vector<pair<ll, ll>>
#define pll pair<ll, ll>
#define pii pair<int, int>
#define pq priority_queue<int>
#define khtm "\n"
#define F first
#define S second
#define fr(i, a, n) for (i = a; i < n; i++)
#define mem(arr, l) memset(arr, l, sizeof arr)
#define ALL(x) x.begin(), x.end()
#define frr(i, a, n) for (i = n - 1; i >= a; i--)
#define fast \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define testcase \
ll T; \
cin >> T; \
while (T--)
const double pi = 3.14159265359;
const int MAX = 1e6 + 2;
const ll inf = 1e18;
const int N = 1010;
// const ll mod = 998244353 ;
const ll mod = 1e9 + 7;
inline ll add(ll a, ll b) {
a += b;
if (a >= mod)
a -= mod;
return a;
}
inline ll mul(ll a, ll b) { return ((a % mod) * 1ll * b) % mod; }
inline ll power(ll a, ll b) {
ll rt = 1;
while (b > 0) {
if (b & 1)
rt = mul(rt, a);
a = mul(a, a);
b >>= 1;
}
return rt;
}
/*
important builtin functions
__gcd(value1, value2)
__builtin_ffs(x)
Number of leading zeroes: __builtin_clz(x)
Number of trailing zeroes : __builtin_ctz(x)
Number of set bits: __builtin_popcount(x)
*/
ll i, j, k, l, m, r, n;
// ll a[MAX],b[MAX];
ll dp[MAX][5];
int main() {
// cout << setprecision(15) << fixed;
fast
cin >>
n >> k;
fr(i, 1, 1 + n) {
ll a, b, c;
cin >> a >> b >> c;
dp[i][1] = max(dp[i - 1][2], dp[i - 1][3]) + a;
dp[i][2] = max(dp[i - 1][1], dp[i - 1][3]) + b;
dp[i][3] = max(dp[i - 1][2], dp[i - 1][1]) + c;
}
ll ans = -1;
fr(i, 1, 4) ans = max(dp[n][i], ans);
cout << ans;
return 0;
}
| /*
auth - @sportykush
*/
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
typedef long long int ll;
typedef long double ld;
typedef tree<ll, null_type, less<ll>, rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;
//#define mp make_pair
#define bug(v) cerr << #v << " = " << (v) << endl;
#define ERASE(x) x.erase(unique(x.begin(), x.end()), x.end())
#define pb emplace_back
#define vii vector<int>
#define vll vector<ll>
#define vpll vector<pair<ll, ll>>
#define pll pair<ll, ll>
#define pii pair<int, int>
#define pq priority_queue<int>
#define khtm "\n"
#define F first
#define S second
#define fr(i, a, n) for (i = a; i < n; i++)
#define mem(arr, l) memset(arr, l, sizeof arr)
#define ALL(x) x.begin(), x.end()
#define frr(i, a, n) for (i = n - 1; i >= a; i--)
#define fast \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define testcase \
ll T; \
cin >> T; \
while (T--)
const double pi = 3.14159265359;
const int MAX = 1e6 + 2;
const ll inf = 1e18;
const int N = 1010;
// const ll mod = 998244353 ;
const ll mod = 1e9 + 7;
inline ll add(ll a, ll b) {
a += b;
if (a >= mod)
a -= mod;
return a;
}
inline ll mul(ll a, ll b) { return ((a % mod) * 1ll * b) % mod; }
inline ll power(ll a, ll b) {
ll rt = 1;
while (b > 0) {
if (b & 1)
rt = mul(rt, a);
a = mul(a, a);
b >>= 1;
}
return rt;
}
/*
important builtin functions
__gcd(value1, value2)
__builtin_ffs(x)
Number of leading zeroes: __builtin_clz(x)
Number of trailing zeroes : __builtin_ctz(x)
Number of set bits: __builtin_popcount(x)
*/
ll i, j, k, l, m, r, n;
// ll a[MAX],b[MAX];
ll dp[MAX][5];
int main() {
// cout << setprecision(15) << fixed;
fast
cin >>
n;
fr(i, 1, 1 + n) {
ll a, b, c;
cin >> a >> b >> c;
dp[i][1] = max(dp[i - 1][2], dp[i - 1][3]) + a;
dp[i][2] = max(dp[i - 1][1], dp[i - 1][3]) + b;
dp[i][3] = max(dp[i - 1][2], dp[i - 1][1]) + c;
}
ll ans = -1;
fr(i, 1, 4) ans = max(dp[n][i], ans);
cout << ans;
return 0;
}
| [
"variable_declaration.remove"
] | 963,122 | 963,123 | u897990209 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int A, A0, B, B0, C, C0;
cin >> A >> B >> C;
A0 = A;
B0 = B;
C0 = C;
for (int i = 1; i < N; i++) {
cin >> A >> B >> C;
int a0, b0, c0;
a0 = A + max(B0, C0);
b0 = A + max(A0, C0);
c0 = A + max(B0, A0);
A0 = a0;
B0 = b0;
C0 = c0;
}
cout << max(A0, max(B0, C0));
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int A, A0, B, B0, C, C0;
cin >> A >> B >> C;
A0 = A;
B0 = B;
C0 = C;
for (int i = 1; i < N; i++) {
cin >> A >> B >> C;
int a0, b0, c0;
a0 = A + max(B0, C0);
b0 = B + max(A0, C0);
c0 = C + max(B0, A0);
A0 = a0;
B0 = b0;
C0 = c0;
}
cout << max(A0, max(B0, C0));
return 0;
} | [
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 963,127 | 963,128 | u608574730 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
const ll INF = 1LL << 60;
#define rep1(i, n) for (ll i = 0; i < (n); i++)
#define rep2(i, k, n) for (ll i = k; i < (n); i++)
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
// 入力
int N;
ll a[100010], b[100010], c[100010];
// DP テーブル
ll dp[100010][3];
int main() {
int N;
cin >> N;
rep1(i, N) cin >> a[i] >> b[i] >> c[i];
// 初期化 (最小化問題なので INF に初期化)
rep1(i, 100010) { rep1(j, 3) dp[i][j] = 0; }
// ループ
rep1(i, N) {
chmax(dp[i + 1][0], dp[i][1] + a[i]);
chmax(dp[i + 1][0], dp[i][2] + a[i]);
chmax(dp[i + 1][0], dp[i][0] + b[i]);
chmax(dp[i + 1][0], dp[i][2] + b[i]);
chmax(dp[i + 1][0], dp[i][0] + c[i]);
chmax(dp[i + 1][0], dp[i][1] + c[i]);
}
ll ans = 0;
rep1(i, 3) chmax(ans, dp[N][i]);
// 答え
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
const ll INF = 1LL << 60;
#define rep1(i, n) for (ll i = 0; i < (n); i++)
#define rep2(i, k, n) for (ll i = k; i < (n); i++)
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
// 入力
int N;
ll a[100010], b[100010], c[100010];
// DP テーブル
ll dp[100010][3];
int main() {
int N;
cin >> N;
rep1(i, N) cin >> a[i] >> b[i] >> c[i];
// 初期化 (最小化問題なので INF に初期化)
rep1(i, 100010) { rep1(j, 3) dp[i][j] = 0; }
// ループ
rep1(i, N) {
chmax(dp[i + 1][0], dp[i][1] + a[i]);
chmax(dp[i + 1][0], dp[i][2] + a[i]);
chmax(dp[i + 1][1], dp[i][0] + b[i]);
chmax(dp[i + 1][1], dp[i][2] + b[i]);
chmax(dp[i + 1][2], dp[i][0] + c[i]);
chmax(dp[i + 1][2], dp[i][1] + c[i]);
}
ll ans = 0;
rep1(i, 3) chmax(ans, dp[N][i]);
// 答え
cout << ans << endl;
}
| [
"literal.number.change",
"variable_access.subscript.index.change",
"call.arguments.change"
] | 963,131 | 963,132 | u913016812 | cpp |
p03162 |
#include <bits/stdc++.h>
using namespace std;
int solve(vector<int> &a, vector<int> &b, vector<int> &c) {
vector<int> dp(3);
dp[0] = a[0];
dp[1] = a[1];
dp[2] = a[2];
int x, y, z;
for (int i = 1; i < a.size(); i++) {
x = max(dp[1] + a[i], dp[2] + a[i]);
y = max(dp[0] + b[i], dp[2] + b[i]);
z = max(dp[1] + c[i], dp[0] + c[i]);
dp[0] = x;
dp[1] = y;
dp[2] = z;
}
return max({dp[0], dp[1], dp[2]});
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
vector<int> a(n), b(n), c(n);
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i] >> c[i];
}
cout << solve(a, b, c) << endl;
} |
#include <bits/stdc++.h>
using namespace std;
int solve(vector<int> &a, vector<int> &b, vector<int> &c) {
vector<int> dp(3);
dp[0] = a[0];
dp[1] = b[0];
dp[2] = c[0];
int x, y, z;
for (int i = 1; i < a.size(); i++) {
x = max(dp[1] + a[i], dp[2] + a[i]);
y = max(dp[0] + b[i], dp[2] + b[i]);
z = max(dp[1] + c[i], dp[0] + c[i]);
// cout<<x<<" "<<y<<" "<<z<<endl;
dp[0] = x;
dp[1] = y;
dp[2] = z;
}
return max({dp[0], dp[1], dp[2]});
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
vector<int> a(n), b(n), c(n);
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i] >> c[i];
}
cout << solve(a, b, c) << endl;
} | [
"assignment.value.change",
"identifier.change",
"literal.number.change",
"variable_access.subscript.index.change"
] | 963,135 | 963,136 | u754735988 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.