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 <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
// ****************************************CODE***************************************//
ll n, a[100100][3];
ll dp[100100][3];
int main() {
cin >> n;
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][i], dp[i][j] + a[i][k]);
}
}
}
ll res = 0;
for (int i = 0; i < 3; i++) {
res = max(res, dp[n][i]);
}
cout << res << endl;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
// ****************************************CODE***************************************//
ll n, a[100100][3];
ll dp[100100][3];
int main() {
cin >> n;
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]);
}
}
}
ll res = 0;
for (int i = 0; i < 3; i++) {
res = max(res, dp[n][i]);
}
cout << res << endl;
} | [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change"
] | 963,624 | 963,625 | u195054737 | cpp |
p03162 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define _upgrade \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define pb push_back
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
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;
}
// ****************************************CODE***************************************//
ll n;
ll abc[110000][3];
ll dp[110000][3];
int main() {
cin >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < 3; j++)
cin >> abc[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] + abc[i][k]);
}
}
}
ll res;
for (int i = 0; i < 3; i++) {
res = max(res, dp[n][i]);
}
cout << res << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define _upgrade \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define pb push_back
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
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;
}
// ****************************************CODE***************************************//
ll n;
ll abc[110000][3];
ll dp[110000][3];
int main() {
cin >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < 3; j++)
cin >> abc[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] + abc[i][k]);
}
}
}
ll res = 0;
for (int i = 0; i < 3; i++) {
res = max(res, dp[n][i]);
}
cout << res << endl;
return 0;
} | [
"variable_declaration.value.change"
] | 963,626 | 963,627 | u195054737 | cpp |
p03162 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define _upgrade \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define pb push_back
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
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;
}
// ****************************************CODE***************************************//
ll n;
ll abc[110000][3];
ll dp[110000][3];
int main() {
cin >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < 3; j++)
cin >> abc[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] = min(dp[i + 1][k], dp[i][j] + abc[i][k]);
}
}
}
ll res;
for (int i = 0; i < 3; i++) {
res = max(res, dp[n][i]);
}
cout << res << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define _upgrade \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define pb push_back
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
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;
}
// ****************************************CODE***************************************//
ll n;
ll abc[110000][3];
ll dp[110000][3];
int main() {
cin >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < 3; j++)
cin >> abc[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] + abc[i][k]);
}
}
}
ll res = 0;
for (int i = 0; i < 3; i++) {
res = max(res, dp[n][i]);
}
cout << res << endl;
return 0;
} | [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change",
"variable_declaration.value.change"
] | 963,628 | 963,627 | u195054737 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define INF (1LL << 60)
#define REP(i, m, n) for (ll(i) = (m), i##_len = (n); (i) < (i##_len); ++(i))
#define FORR(i, v) for (auto(i) : v)
#define ALL(x) (x).begin(), (x).end()
#define _PR(x) cout << (x) << endl
#define _PS(x) cout << (x) << " "
#define SZ(x) ((int)(x).size())
#define MAX(a, b) (((a) > (b)) ? (a) : (b))
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
#define pb push_back
int main() {
ll N;
cin >> N;
vector<vector<ll>> a(N, vector<ll>(3));
REP(i, 0, N) cin >> a[i][0] >> a[i][1] >> a[i][2];
vector<vector<ll>> dp(N + 1, vector<ll>(3, 0));
REP(i, 0, N) {
REP(j, 0, 3) {
REP(k, 0, 3) {
if (j == k)
continue;
dp[i + 1][j] = MAX(dp[i + 1][j], dp[i][j] + a[i][k]);
}
}
}
ll M = 0;
REP(i, 0, 3) { M = MAX(M, dp[N][i]); }
_PR(M);
return 0;
}
/*
*/ | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define INF (1LL << 60)
#define REP(i, m, n) for (ll(i) = (m), i##_len = (n); (i) < (i##_len); ++(i))
#define FORR(i, v) for (auto(i) : v)
#define ALL(x) (x).begin(), (x).end()
#define _PR(x) cout << (x) << endl
#define _PS(x) cout << (x) << " "
#define SZ(x) ((int)(x).size())
#define MAX(a, b) (((a) > (b)) ? (a) : (b))
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
#define pb push_back
int main() {
ll N;
cin >> N;
vector<vector<ll>> a(N, vector<ll>(3));
REP(i, 0, N) cin >> a[i][0] >> a[i][1] >> a[i][2];
vector<vector<ll>> dp(N + 1, vector<ll>(3, 0));
REP(i, 0, N) {
REP(j, 0, 3) {
REP(k, 0, 3) {
if (j == k)
continue;
dp[i + 1][k] = MAX(dp[i + 1][k], dp[i][j] + a[i][k]);
}
}
}
ll M = 0;
REP(i, 0, 3) { M = MAX(M, dp[N][i]); }
_PR(M);
return 0;
}
/*
*/ | [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change",
"assignment.value.change",
"call.arguments.change"
] | 963,629 | 963,630 | u768347697 | cpp |
p03162 | #include <cmath>
#include <iostream>
#include <string>
typedef long long lint;
using namespace std;
// dpテンプレ
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 n;
lint h[100000][3] = {};
// dpテーブル
lint dp[100000][3] = {};
int main() {
int n, i, j, k;
lint ans;
cin >> n;
for (i = 0; i < n; i++) {
for (j = 0; j < 3; j++) {
cin >> h[i][j];
}
}
//初期値
for (i = 0; i < 3; i++) {
dp[0][i] = h[0][i];
}
//ループ
for (i = 1; i < n; i++) {
for (j = 0; j < 3; j++) {
for (k = 0; k < 3; k++) {
if (j == k)
continue;
chmax(dp[i][j], dp[i - 1][j] + h[i][k]);
}
}
}
ans = 0;
for (i = 0; i < 3; i++) {
chmax(ans, dp[n - 1][i]);
}
cout << ans;
}
| #include <cmath>
#include <iostream>
#include <string>
typedef long long lint;
using namespace std;
// dpテンプレ
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 n;
lint h[100000][3] = {};
// dpテーブル
lint dp[100000][3] = {};
int main() {
int n, i, j, k;
lint ans;
cin >> n;
for (i = 0; i < n; i++) {
for (j = 0; j < 3; j++) {
cin >> h[i][j];
}
}
//初期値
for (i = 0; i < 3; i++) {
dp[0][i] = h[0][i];
}
//ループ
for (i = 1; i < n; i++) {
for (j = 0; j < 3; j++) {
for (k = 0; k < 3; k++) {
if (j == k)
continue;
chmax(dp[i][j], dp[i - 1][k] + h[i][j]);
}
}
}
ans = 0;
for (i = 0; i < 3; i++) {
chmax(ans, dp[n - 1][i]);
}
cout << ans;
}
| [
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 963,640 | 963,641 | u664272778 | cpp |
p03162 | #include <iostream>
#include <stdio.h>
//#include <bits/stdc++.h>
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cmath>
#include <cstring>
#include <float.h>
#include <iomanip>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#define INF 1e9
#define rep(i, n) for (int i = 0; (i) < (int)(n); i++)
#define REP(i, a, b) for (int i = (int)(a); (i) <= (int)(b); i++)
#define VEC(type, c, n) \
std::vector<type> c(n); \
for (auto &i : c) \
std::cin >> i;
#define vec(type, n) vector<type>(n)
#define vvec(m, n) vector<vector<int>>(int(m), vector<int>(n))
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
using P = pair<int, int>;
int dp[100005][3];
int main() {
int n;
cin >> n;
auto a = vec(int, n);
auto b = vec(int, n);
auto c = vec(int, n);
rep(i, n) cin >> a[i] >> b[i] >> c[i];
dp[0][0] = a[0];
dp[0][1] = b[0];
dp[0][2] = c[0];
REP(i, 1, n - 1) rep(j, 3) {
if (j == 0) {
dp[i][j] = max(dp[i - 1][1] + a[i], dp[i][2] + a[i]);
}
if (j == 1) {
dp[i][j] = max(dp[i - 1][0] + b[i], dp[i][2] + b[i]);
}
if (j == 2) {
dp[i][j] = max(dp[i - 1][0] + c[i], dp[i][1] + c[i]);
}
}
int res = max({dp[n - 1][0], dp[n - 1][1], dp[n - 1][2]});
cout << res;
}
| #include <iostream>
#include <stdio.h>
//#include <bits/stdc++.h>
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cmath>
#include <cstring>
#include <float.h>
#include <iomanip>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#define INF 1e9
#define rep(i, n) for (int i = 0; (i) < (int)(n); i++)
#define REP(i, a, b) for (int i = (int)(a); (i) <= (int)(b); i++)
#define VEC(type, c, n) \
std::vector<type> c(n); \
for (auto &i : c) \
std::cin >> i;
#define vec(type, n) vector<type>(n)
#define vvec(m, n) vector<vector<int>>(int(m), vector<int>(n))
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
using P = pair<int, int>;
int dp[100005][3];
int main() {
int n;
cin >> n;
auto a = vec(int, n);
auto b = vec(int, n);
auto c = vec(int, n);
rep(i, n) cin >> a[i] >> b[i] >> c[i];
dp[0][0] = a[0];
dp[0][1] = b[0];
dp[0][2] = c[0];
REP(i, 1, n - 1) rep(j, 3) {
if (j == 0) {
dp[i][j] = max(dp[i - 1][1] + a[i], dp[i - 1][2] + a[i]);
}
if (j == 1) {
dp[i][j] = max(dp[i - 1][0] + b[i], dp[i - 1][2] + b[i]);
}
if (j == 2) {
dp[i][j] = max(dp[i - 1][0] + c[i], dp[i - 1][1] + c[i]);
}
}
int res = max({dp[n - 1][0], dp[n - 1][1], dp[n - 1][2]});
cout << res;
}
| [
"assignment.change"
] | 963,644 | 963,645 | u516525290 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.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];
long long dp[n][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++) {
for (int k = 0; k < 3; k++) {
if (j != k) {
dp[i][k] = max(dp[i][k], dp[i - 1][k] + arr[i][j]);
}
}
}
}
int ans = 0;
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;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.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];
int dp[n][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++) {
for (int k = 0; k < 3; k++) {
if (j != k) {
dp[i][k] = max(dp[i][k], dp[i - 1][j] + arr[i][k]);
}
}
}
}
int ans = 0;
ans = max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2]));
cout << ans << endl;
return 0;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.narrow.change",
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 963,646 | 963,647 | u616030860 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.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];
int dp[n][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++) {
for (int k = 0; k < 3; k++) {
if (j != k) {
dp[i][k] = max(dp[i][k], dp[i - 1][k] + arr[i][j]);
}
}
}
}
int ans = 0;
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;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.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];
int dp[n][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++) {
for (int k = 0; k < 3; k++) {
if (j != k) {
dp[i][k] = max(dp[i][k], dp[i - 1][j] + arr[i][k]);
}
}
}
}
int ans = 0;
ans = max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2]));
cout << ans << endl;
return 0;
} | [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 963,648 | 963,647 | u616030860 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.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];
long long dp[n][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++) {
for (int k = 0; k < 3; k++) {
if (j != k) {
dp[i][k] = max(dp[i][k], dp[i - 1][k] + arr[i][j]);
}
}
}
}
int ans = 0;
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;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.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];
long long dp[n][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++) {
for (int k = 0; k < 3; k++) {
if (j != k) {
dp[i][k] = max(dp[i][k], dp[i - 1][j] + arr[i][k]);
}
}
}
}
long long ans = 0;
ans = max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2]));
cout << ans << endl;
return 0;
} | [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change",
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 963,646 | 963,649 | u616030860 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.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];
int dp[n][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++) {
for (int k = 0; k < 3; k++) {
if (j != k) {
dp[i][k] = max(dp[i][k], dp[i - 1][k] + arr[i][j]);
}
}
}
}
int ans = 0;
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;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.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];
long long dp[n][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++) {
for (int k = 0; k < 3; k++) {
if (j != k) {
dp[i][k] = max(dp[i][k], dp[i - 1][j] + arr[i][k]);
}
}
}
}
long long ans = 0;
ans = max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2]));
cout << ans << endl;
return 0;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 963,648 | 963,649 | u616030860 | cpp |
p03162 | #include <iostream>
using namespace std;
int main() {
int days;
cin >> days;
int happy[days][3];
for (int i = 0; i < days; ++i) {
cin >> happy[i][0] >> happy[i][1] >> happy[i][2];
}
int a1, a2, a3;
int temp1, temp2, temp3;
a1 = happy[0][0];
a2 = happy[0][1];
a3 = happy[0][2];
for (int i = 1; i < days; ++i) {
if (a2 > a3)
temp1 = a2 + happy[i][0];
else
temp1 = a3 + happy[i][0];
if (a1 > a3)
temp1 = a1 + happy[i][1];
else
temp1 = a3 + happy[i][1];
if (a2 > a1)
temp1 = a2 + happy[i][2];
else
temp1 = a1 + happy[i][2];
a1 = temp1;
a2 = temp2;
a3 = temp3;
}
if (a2 > a3) {
if (a2 > a1)
cout << a2;
else
cout << a1;
} else {
if (a3 > a1)
cout << a3;
else
cout << a1;
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
int days;
cin >> days;
int happy[days][3];
for (int i = 0; i < days; ++i) {
cin >> happy[i][0] >> happy[i][1] >> happy[i][2];
}
int a1, a2, a3;
int temp1, temp2, temp3;
a1 = happy[0][0];
a2 = happy[0][1];
a3 = happy[0][2];
for (int i = 1; i < days; ++i) {
if (a2 > a3)
temp1 = a2 + happy[i][0];
else
temp1 = a3 + happy[i][0];
if (a1 > a3)
temp2 = a1 + happy[i][1];
else
temp2 = a3 + happy[i][1];
if (a2 > a1)
temp3 = a2 + happy[i][2];
else
temp3 = a1 + happy[i][2];
a1 = temp1;
a2 = temp2;
a3 = temp3;
}
if (a2 > a3) {
if (a2 > a1)
cout << a2;
else
cout << a1;
} else {
if (a3 > a1)
cout << a3;
else
cout << a1;
}
return 0;
} | [
"assignment.variable.change",
"identifier.change"
] | 963,653 | 963,654 | u840752761 | cpp |
p03162 | /*
ID: Barry Wang
LANG: C++11
TASK:
*/
#include <bits/stdc++.h>
using namespace std;
/*---define tricks---*/
#define ALL(v) v.begin(), v.end()
#define UN(v) sort(ALL(v)), v.erase(unique(ALL(v)), v.end())
#define FILL(x, y) memset(x, y, sizeof(x))
#define EACH(v, it) \
for (__typeof(v.begin()) it = v.begin(); it != v.end(); it++)
#define FIO ios::sync_with_stdio(0), cin.tie(0), cout.tie(0)
#define revsort(b, e) sort(b, e), reverse(b, e)
#define X first
#define Y second
#define Chtolly return 0
/*---define types---*/
typedef long long ll;
typedef list<int> li;
typedef queue<int> qi;
typedef deque<int> dqi;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef vector<pii> vii;
typedef pair<ll, ll> pll;
typedef pair<ll, int> pli;
typedef unsigned int uint;
/*---define variables---*/
const int inf = (1 << 29);
int n, lim;
ll h[100005][3], dp[100005][3];
/*---define function---*/
/*---main code---*/
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
dp[i][0] = -2147483647;
dp[i][2] = -2147483647;
dp[i][2] = -2147483647;
cin >> h[i][0] >> h[i][1] >> h[i][2];
}
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < 3; ++j) {
for (int k = 0; k < 3; ++k) {
if (k == j) {
continue;
}
dp[i][j] = max(dp[i][j], dp[i - 1][k] + h[i - 1][k]);
}
}
}
cout << max(dp[n + 1][0], max(dp[n + 1][1], dp[n + 1][2])) << '\n';
return 0;
}
| /*
ID: Barry Wang
LANG: C++11
TASK:
*/
#include <bits/stdc++.h>
using namespace std;
/*---define tricks---*/
#define ALL(v) v.begin(), v.end()
#define UN(v) sort(ALL(v)), v.erase(unique(ALL(v)), v.end())
#define FILL(x, y) memset(x, y, sizeof(x))
#define EACH(v, it) \
for (__typeof(v.begin()) it = v.begin(); it != v.end(); it++)
#define FIO ios::sync_with_stdio(0), cin.tie(0), cout.tie(0)
#define revsort(b, e) sort(b, e), reverse(b, e)
#define X first
#define Y second
#define Chtolly return 0
/*---define types---*/
typedef long long ll;
typedef list<int> li;
typedef queue<int> qi;
typedef deque<int> dqi;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef vector<pii> vii;
typedef pair<ll, ll> pll;
typedef pair<ll, int> pli;
typedef unsigned int uint;
/*---define variables---*/
const int inf = (1 << 29);
int n, lim;
ll h[100005][3], dp[100005][3];
/*---define function---*/
/*---main code---*/
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
dp[i][0] = -2147483647;
dp[i][2] = -2147483647;
dp[i][2] = -2147483647;
cin >> h[i][0] >> h[i][1] >> h[i][2];
}
for (int i = 1; i <= n + 1; ++i) {
for (int j = 0; j < 3; ++j) {
for (int k = 0; k < 3; ++k) {
if (k == j) {
continue;
}
dp[i][j] = max(dp[i][j], dp[i - 1][k] + h[i - 1][k]);
}
}
}
cout << max(dp[n + 1][0], max(dp[n + 1][1], dp[n + 1][2])) << '\n';
return 0;
}
| [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 963,669 | 963,670 | u734192058 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < int(n); ++i)
int main() {
int N;
cin >> N;
vector<int> a(N), b(N), c(N);
int dp[N + 100][3] = {};
rep(i, N) cin >> a.at(i) >> b.at(i) >> c.at(i);
dp[0][0] = a.at(0);
dp[0][1] = b.at(0);
dp[0][2] = c.at(0);
for (int i = 0; i < N - 1; ++i) {
for (int j = 0; j < 3; ++j) {
int happiness = (j == 0) ? max(dp[i][1], dp[i][2]) + a.at(i + 1)
: (j == 1) ? max(dp[i][0], dp[i][2]) + b.at(i + 1)
: max(dp[i][1], dp[i][2]) + c.at(i + 1);
dp[i + 1][j] = happiness;
}
}
int mx = max(dp[N - 1][0], dp[N - 1][1]);
mx = max(mx, dp[N - 1][2]);
cout << mx << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < int(n); ++i)
int main() {
int N;
cin >> N;
vector<int> a(N), b(N), c(N);
int dp[N + 100][3] = {};
rep(i, N) cin >> a.at(i) >> b.at(i) >> c.at(i);
dp[0][0] = a.at(0);
dp[0][1] = b.at(0);
dp[0][2] = c.at(0);
for (int i = 0; i < N - 1; ++i) {
for (int j = 0; j < 3; ++j) {
int happiness = (j == 0) ? max(dp[i][1], dp[i][2]) + a.at(i + 1)
: (j == 1) ? max(dp[i][0], dp[i][2]) + b.at(i + 1)
: max(dp[i][0], dp[i][1]) + c.at(i + 1);
dp[i + 1][j] = happiness;
}
}
int mx = max(dp[N - 1][0], dp[N - 1][1]);
mx = max(mx, dp[N - 1][2]);
cout << mx << endl;
return 0;
} | [
"literal.number.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 963,676 | 963,677 | u741815956 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < int(n); ++i)
int main() {
int N;
cin >> N;
vector<int> a(N), b(N), c(N);
int dp[N + 100][3] = {};
rep(i, N) cin >> a.at(i) >> b.at(i) >> c.at(i);
dp[0][0] = a.at(0);
dp[0][1] = b.at(0);
dp[0][2] = c.at(0);
for (int i = 0; i < N - 1; ++i) {
for (int j = 0; j < 3; ++j) {
int happiness = (j == 0) ? max(dp[i][1], dp[i][2]) + a.at(i + 1)
: (j == 1) ? max(dp[i][0], dp[i][2]) + b.at(i + 1)
: max(dp[i][1], dp[i][2]) + c.at(i + 1);
dp[i + 1][j] = happiness;
}
}
int mx = max(dp[N - 1][0], dp[N - 1][1]);
mx = max(mx, dp[N - 1][1]);
cout << mx << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < int(n); ++i)
int main() {
int N;
cin >> N;
vector<int> a(N), b(N), c(N);
int dp[N + 100][3] = {};
rep(i, N) cin >> a.at(i) >> b.at(i) >> c.at(i);
dp[0][0] = a.at(0);
dp[0][1] = b.at(0);
dp[0][2] = c.at(0);
for (int i = 0; i < N - 1; ++i) {
for (int j = 0; j < 3; ++j) {
int happiness = (j == 0) ? max(dp[i][1], dp[i][2]) + a.at(i + 1)
: (j == 1) ? max(dp[i][0], dp[i][2]) + b.at(i + 1)
: max(dp[i][0], dp[i][1]) + c.at(i + 1);
dp[i + 1][j] = happiness;
}
}
int mx = max(dp[N - 1][0], dp[N - 1][1]);
mx = max(mx, dp[N - 1][2]);
cout << mx << endl;
return 0;
} | [
"literal.number.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change",
"assignment.value.change"
] | 963,678 | 963,677 | u741815956 | cpp |
p03162 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
const int maxn = 1e4;
int a[maxn][maxn];
int dp[maxn][maxn];
int main() {
int n;
cin >> n;
dp[0][0] = 0;
dp[0][1] = 0;
dp[0][2] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 3; j++) {
cin >> a[i - 1][j];
}
dp[i][0] = a[i - 1][0] + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = a[i - 1][1] + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = a[i - 1][2] + max(dp[i - 1][0], dp[i - 1][1]);
}
cout << max(dp[n][0], max(dp[n][1], dp[n][2]));
return 0;
}
| #include <bits/stdc++.h>
#include <iostream>
using namespace std;
const int maxn = 1e5;
int a[maxn][3];
int dp[maxn][3];
int main() {
int n;
cin >> n;
dp[0][0] = 0;
dp[0][1] = 0;
dp[0][2] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 3; j++) {
cin >> a[i - 1][j];
}
dp[i][0] = a[i - 1][0] + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = a[i - 1][1] + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = a[i - 1][2] + max(dp[i - 1][0], dp[i - 1][1]);
}
cout << max(dp[n][0], max(dp[n][1], dp[n][2]));
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"identifier.replace.remove",
"literal.replace.add",
"variable_declaration.array_dimensions.change"
] | 963,695 | 963,696 | u047353219 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef pair<int, int> ii;
typedef pair<ll, int> li;
typedef pair<int, ll> il;
typedef vector<ii> vii;
typedef vector<il> vil;
typedef vector<li> vli;
#define F first
#define S second
#define pb(x) push_back(x)
#define mp(a, b) make_pair(a, b)
#define mt(a, b, c) make_tuple(a, b, c)
#define sz size()
#define all(A) A.begin(), A.end()
#define mem(a, b) \
memset(a, b, sizeof(a)) // all elements of A are b=0 or b=-1 else don't work
#define f0(i, b) for (ll i = 0; i < (b); i++)
#define f1(i, b) for (ll i = 1; i <= (b); i++)
#define f2(i, a, b) for (ll i = (a); i <= (b); i++)
#define f3(i, b, a) for (ll i = (b); i >= (a); i--)
#define rep(i, a, b, c) for (ll i = (a); i != (b); i += (c))
#define mod 10000007
#define PI acos(-1.0)
#define MAX3(a, b, c) max(a, max(b, c))
/*------------------------Bitmask-------------------------------*/
#define bitOn(N, pos) (N | (1LL << (pos)))
#define bitOff(N, pos) (N & (~(1LL << (pos))))
#define bitCheck(N, pos) ((bool)(N & (1LL << (pos))))
#define bitFlip(a, k) (a ^ (1LL << (k)))
#define whilee(i, t) while (i != t)
#define sl(a) scanf("%lld", &a)
#define pl(a) printf("%lld\n", a)
// x = 1e18 means 10^18
// for(auto it =A.begin(); it!=A.end(); it++)
// sort(A.begin(),A.end()); //sort(A, +n, greater<int>());
// binary_search(A.begin(),A.end(),x);
// reverse(A.begin(), A.end());
// cout << *max_element(A.begin(), A.end());
// cout << *min_element(A.begin(), A.end());
// count(A.begin(), A.end(), X); //counts the occurrences of X
// distance(A.begin(),A.end()); //distance between first to last element
// accumulate(A.begin(), A.end(), 0); //add
// next_permutation(A.begin(), A.end());
// prev_permutation(A.begin(), A.end());
// swap(S[0], T[0]);
// scanf("%lld",&x);
// printf("%lld\n",x);
// printf("%I64d\n", a);
// while (scanf("%lld %lld", &a, &b) == 2)
// printf("Case %lld: %lld\n", t++, a);
/*----------------------- Graph Moves---------------------------*/
// int dx[] = {1,-1,0,0} , dy[] = {0,0,1,-1}; // 4 Direction
// int dx[] = {1,-1,0,0,1,1,-1,-1} , dy[] = {0,0,1,-1,1,-1,1,-1}; // 8
// Direction // Kings Move int dx[] = {1,-1,1,-1,2,2,-2,-2} , dy[] =
// {2,2,-2,-2,1,-1,1,-1}; // Knight Direction int dx[] = {2,-2,1,1,-1,-1} ,
// dy[] = {0,0,1,-1,1,-1}; // Hexagonal Direction
// vector <ll> A;
// deque <ll> A;
// queue <ll> A;
// stack <ll> A;
// list <int> A;
// set <ll> A;
// map <ll,ll> A;
// unordered_map <ll, ll> A;
// pair <ll,ll> A ;
// tuple <ll, ll, ll> A;
// vector <pair <ll,ll>> A;
// bitset<32> bset1;
// bool ok = true;
// char ch;
// string S, T, U;
ll i = 0, j = 0, k = 0, a, b, c, d, e, f, g, h, l, m, n, o, p, q, r, s, t = 1,
u, v, w, x, y, z, maxx = INT_MIN, minn = INT_MAX, ans = 0, sum = 0, flag = 0,
cnt = 0;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr); // NULL
cout.tie(nullptr); // NULL
cin >> n;
vector<ll> dp(3, 0);
f0(x, n) {
vector<ll> Ndp(3, 0);
vector<ll> A(3);
f0(i, n) { cin >> A[i]; }
f0(i, n) {
f0(j, n) {
if (i != j)
Ndp[j] = max(Ndp[j], dp[i] + A[j]);
}
}
dp = Ndp;
}
cout << *max_element(all(dp)) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef pair<int, int> ii;
typedef pair<ll, int> li;
typedef pair<int, ll> il;
typedef vector<ii> vii;
typedef vector<il> vil;
typedef vector<li> vli;
#define F first
#define S second
#define pb(x) push_back(x)
#define mp(a, b) make_pair(a, b)
#define mt(a, b, c) make_tuple(a, b, c)
#define sz size()
#define all(A) A.begin(), A.end()
#define mem(a, b) \
memset(a, b, sizeof(a)) // all elements of A are b=0 or b=-1 else don't work
#define f0(i, b) for (ll i = 0; i < (b); i++)
#define f1(i, b) for (ll i = 1; i <= (b); i++)
#define f2(i, a, b) for (ll i = (a); i <= (b); i++)
#define f3(i, b, a) for (ll i = (b); i >= (a); i--)
#define rep(i, a, b, c) for (ll i = (a); i != (b); i += (c))
#define mod 10000007
#define PI acos(-1.0)
#define MAX3(a, b, c) max(a, max(b, c))
/*------------------------Bitmask-------------------------------*/
#define bitOn(N, pos) (N | (1LL << (pos)))
#define bitOff(N, pos) (N & (~(1LL << (pos))))
#define bitCheck(N, pos) ((bool)(N & (1LL << (pos))))
#define bitFlip(a, k) (a ^ (1LL << (k)))
#define whilee(i, t) while (i != t)
#define sl(a) scanf("%lld", &a)
#define pl(a) printf("%lld\n", a)
// x = 1e18 means 10^18
// for(auto it =A.begin(); it!=A.end(); it++)
// sort(A.begin(),A.end()); //sort(A, +n, greater<int>());
// binary_search(A.begin(),A.end(),x);
// reverse(A.begin(), A.end());
// cout << *max_element(A.begin(), A.end());
// cout << *min_element(A.begin(), A.end());
// count(A.begin(), A.end(), X); //counts the occurrences of X
// distance(A.begin(),A.end()); //distance between first to last element
// accumulate(A.begin(), A.end(), 0); //add
// next_permutation(A.begin(), A.end());
// prev_permutation(A.begin(), A.end());
// swap(S[0], T[0]);
// scanf("%lld",&x);
// printf("%lld\n",x);
// printf("%I64d\n", a);
// while (scanf("%lld %lld", &a, &b) == 2)
// printf("Case %lld: %lld\n", t++, a);
/*----------------------- Graph Moves---------------------------*/
// int dx[] = {1,-1,0,0} , dy[] = {0,0,1,-1}; // 4 Direction
// int dx[] = {1,-1,0,0,1,1,-1,-1} , dy[] = {0,0,1,-1,1,-1,1,-1}; // 8
// Direction // Kings Move int dx[] = {1,-1,1,-1,2,2,-2,-2} , dy[] =
// {2,2,-2,-2,1,-1,1,-1}; // Knight Direction int dx[] = {2,-2,1,1,-1,-1} ,
// dy[] = {0,0,1,-1,1,-1}; // Hexagonal Direction
// vector <ll> A;
// deque <ll> A;
// queue <ll> A;
// stack <ll> A;
// list <int> A;
// set <ll> A;
// map <ll,ll> A;
// unordered_map <ll, ll> A;
// pair <ll,ll> A ;
// tuple <ll, ll, ll> A;
// vector <pair <ll,ll>> A;
// bitset<32> bset1;
// bool ok = true;
// char ch;
// string S, T, U;
ll i = 0, j = 0, k = 0, a, b, c, d, e, f, g, h, l, m, n, o, p, q, r, s, t = 1,
u, v, w, x, y, z, maxx = INT_MIN, minn = INT_MAX, ans = 0, sum = 0, flag = 0,
cnt = 0;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr); // NULL
cout.tie(nullptr); // NULL
cin >> n;
vector<ll> dp(3, 0);
f0(x, n) {
vector<ll> Ndp(3, 0);
vector<ll> A(3);
f0(i, 3) { cin >> A[i]; }
f0(i, 3) {
f0(j, 3) {
if (i != j)
Ndp[j] = max(Ndp[j], dp[i] + A[j]);
}
}
dp = Ndp;
}
cout << *max_element(all(dp)) << endl;
return 0;
}
| [] | 963,701 | 963,702 | u779159351 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> dp(3, 0);
for (int day = 0; day < n; day++) {
vector<int> c(3, 0);
vector<int> new_dp(3, 0);
for (int i = 0; i < 3; i++) {
cin >> c[i];
}
for (int i = 0; i < 3; i++) {
for (int j = 0; j < n; j++) {
if (i != j) {
new_dp[j] = max(new_dp[j], dp[i] + c[j]);
}
}
}
dp = new_dp;
}
cout << max(dp[0], max(dp[1], dp[2])) << endl;
return 0;
}; | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> dp(3, 0);
for (int day = 0; day < n; day++) {
vector<int> c(3, 0);
vector<int> new_dp(3, 0);
for (int i = 0; i < 3; i++) {
cin >> c[i];
}
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], max(dp[1], dp[2])) << endl;
return 0;
}; | [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 963,703 | 963,704 | u366686355 | cpp |
p03162 | #include <bits/stdc++.h>
#define fff(i, a, b) for (int(i) = (a); (i) <= (b); i++)
#define pb push_back
#define len(a) (a).length()
#define all(a) (a).begin(), (a).end()
#define sz(a) (a).size()
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<long long, long long> pll;
typedef unsigned long long ull;
typedef long double ld;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int a, b, c;
int dpa[n];
int dpb[n];
int dpc[n];
fff(i, 0, n - 1) {
cin >> a >> b >> c;
if (i == 0) {
dpa[0] = a;
dpb[0] = b;
dpc[0] = b;
} else {
dpa[i] = max(dpb[i - 1], dpc[i - 1]) + a;
dpb[i] = max(dpa[i - 1], dpc[i - 1]) + b;
dpc[i] = max(dpa[i - 1], dpc[i - 1]) + c;
}
}
cout << max(max(dpc[n - 1], dpb[n - 1]), dpa[n - 1]) << endl;
return 0;
} | #include <bits/stdc++.h>
#define fff(i, a, b) for (int(i) = (a); (i) <= (b); i++)
#define pb push_back
#define len(a) (a).length()
#define all(a) (a).begin(), (a).end()
#define sz(a) (a).size()
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<long long, long long> pll;
typedef unsigned long long ull;
typedef long double ld;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int a, b, c;
int dpa[n];
int dpb[n];
int dpc[n];
fff(i, 0, n - 1) {
cin >> a >> b >> c;
if (i == 0) {
dpa[0] = a;
dpb[0] = b;
dpc[0] = c;
} else {
dpa[i] = max(dpb[i - 1], dpc[i - 1]) + a;
dpb[i] = max(dpa[i - 1], dpc[i - 1]) + b;
dpc[i] = max(dpa[i - 1], dpb[i - 1]) + c;
}
}
cout << max(max(dpc[n - 1], dpb[n - 1]), dpa[n - 1]) << endl;
return 0;
} | [
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 963,711 | 963,712 | u504771112 | cpp |
p03162 | #include <bits/stdc++.h>
#define int long long
#define fi first
#define sc second
#define pii pair<int, int>
#define vi vector<int>
#define msi map<string, int>
#define si set<int>
#define all(v) v.begin(), v.end()
#define sz(v) int((v).size())
#define rep(i, a, b) for (int i = a; i < b; i++)
#define dep(i, a, b) for (int i = a; i >= b; i--)
#define isinarr(i, n) ((i >= 0) ? ((i < n) ? 1 : 0) : 0)
#define fastio \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define pb push_back
#define ppb pop_back
#define present(container, element) \
(container.find(element) != container.end()) // set,map etc.
#define cpresent(container, element) \
(find(all(container), element) != container.end()) // vector
#define hell 1000000007
#define PI 3.14159265
#define mp make_pair
#define endl '\n'
using namespace std;
void solve() {
int n;
cin >> n;
int dp[n + 1][3];
int x, y, z;
dp[0][0] = 0;
dp[0][1] = 0;
dp[0][2] = 0;
rep(i, 0, n) {
cin >> x >> y >> z;
dp[i + 1][0] = x + max(dp[i][1], dp[i][2]);
dp[i + 1][1] = y + max(dp[i][0], dp[i][2]);
dp[i + 1][2] = z + max(dp[i][1], dp[i][0]);
}
cout << max(dp[n][0], max(dp[n][1], dp[n][2]));
}
signed main() {
fastio int t = 1;
cin >> t;
while (t--)
solve();
return 0;
} | #include <bits/stdc++.h>
#define int long long
#define fi first
#define sc second
#define pii pair<int, int>
#define vi vector<int>
#define msi map<string, int>
#define si set<int>
#define all(v) v.begin(), v.end()
#define sz(v) int((v).size())
#define rep(i, a, b) for (int i = a; i < b; i++)
#define dep(i, a, b) for (int i = a; i >= b; i--)
#define isinarr(i, n) ((i >= 0) ? ((i < n) ? 1 : 0) : 0)
#define fastio \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define pb push_back
#define ppb pop_back
#define present(container, element) \
(container.find(element) != container.end()) // set,map etc.
#define cpresent(container, element) \
(find(all(container), element) != container.end()) // vector
#define hell 1000000007
#define PI 3.14159265
#define mp make_pair
#define endl '\n'
using namespace std;
void solve() {
int n;
cin >> n;
int dp[n + 1][3];
int x, y, z;
dp[0][0] = 0;
dp[0][1] = 0;
dp[0][2] = 0;
rep(i, 0, n) {
cin >> x >> y >> z;
dp[i + 1][0] = x + max(dp[i][1], dp[i][2]);
dp[i + 1][1] = y + max(dp[i][0], dp[i][2]);
dp[i + 1][2] = z + max(dp[i][1], dp[i][0]);
}
cout << max(dp[n][0], max(dp[n][1], dp[n][2]));
}
signed main() {
fastio int t = 1;
while (t--)
solve();
return 0;
}
| [] | 963,723 | 963,724 | u429144503 | cpp |
p03162 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; ++i)
typedef long long ll;
using namespace std;
const ll MOD = 1000000007LL;
struct edge {
int a, b, c;
};
int N;
edge W[100005];
int DP[100005][3]; //日にち, i日目にした活動, i日目までの幸福度の最大値
int main() {
cin.sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> N;
int a, b, c;
rep(i, N) {
cin >> a >> b >> c;
edge e = {a, b, c};
W[i] = e;
}
rep(i, N) {
if (i == 0) {
DP[0][0] = W[0].a;
DP[0][1] = W[0].b;
DP[0][2] = W[0].c;
continue;
}
DP[i][0] = max(DP[i - 1][1] + W[i].a, DP[i - 1][2] + W[i].a);
DP[i][1] = max(DP[i - 1][0] + W[i].b, DP[i - 1][2] + W[i].c);
DP[i][2] = max(DP[i - 1][0] + W[i].a, DP[i - 1][1] + W[i].c);
}
int ans = max(DP[N - 1][0], DP[N - 1][1]);
ans = max(ans, DP[N - 1][2]);
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; ++i)
typedef long long ll;
using namespace std;
const ll MOD = 1000000007LL;
struct edge {
int a, b, c;
};
int N;
edge W[100005];
int DP[100005][3]; //日にち, i日目にした活動, i日目までの幸福度の最大値
int main() {
cin.sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> N;
int a, b, c;
rep(i, N) {
cin >> a >> b >> c;
edge e = {a, b, c};
W[i] = e;
}
rep(i, N) {
if (i == 0) {
DP[0][0] = W[0].a;
DP[0][1] = W[0].b;
DP[0][2] = W[0].c;
continue;
}
DP[i][0] = max(DP[i - 1][1] + W[i].a, DP[i - 1][2] + W[i].a);
DP[i][1] = max(DP[i - 1][0] + W[i].b, DP[i - 1][2] + W[i].b);
DP[i][2] = max(DP[i - 1][0] + W[i].c, DP[i - 1][1] + W[i].c);
}
int ans = max(DP[N - 1][0], DP[N - 1][1]);
ans = max(ans, DP[N - 1][2]);
cout << ans << endl;
return 0;
} | [
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 963,725 | 963,726 | u288087195 | cpp |
p03162 | #include <bits/stdc++.h>
#include <fstream>
#include <string>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> dp(3);
for (int d = 0; d < n; d++) {
vector<int> chk(3, 0);
int vals[3];
for (int j = 0; j < 3; j++)
cin >> vals[j];
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (i != j) {
// chk[j] = max(chk[j], dp[i] + vals[j]);
chk[i] = max(chk[i], dp[j] + vals[i]);
}
}
}
}
cout << max({dp[0], dp[1], dp[2]});
return 0;
} | #include <bits/stdc++.h>
#include <fstream>
#include <string>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> dp(3);
for (int d = 0; d < n; d++) {
vector<int> chk(3, 0);
int vals[3];
for (int j = 0; j < 3; j++)
cin >> vals[j];
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (i != j) {
// chk[j] = max(chk[j], dp[i] + vals[j]);
chk[i] = max(chk[i], dp[j] + vals[i]);
}
}
}
dp = chk;
}
cout << max({dp[0], dp[1], dp[2]});
return 0;
} | [
"assignment.add"
] | 963,735 | 963,736 | u711686772 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX / 2;
int main() {
int N;
cin >> N;
vector<vector<int>> dp(N + 1, {-INF, -INF, -INF});
for (int &i : dp[0])
i = 0;
for (int i = 1; i < N + 1; i++) {
int a[3];
cin >> a[0] >> a[1] >> a[2];
dp[i][0] = max(dp[i - 1][1] + a[1], dp[i - 1][2] + a[2]);
dp[i][1] = max(dp[i - 1][1] + a[0], dp[i - 1][2] + a[2]);
dp[i][2] = max(dp[i - 1][0] + a[0], dp[i - 1][1] + a[1]);
}
cout << *(max_element(dp[N].begin(), dp[N].end())) << endl;
}
| #include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX / 2;
int main() {
int N;
cin >> N;
vector<vector<int>> dp(N + 1, {-INF, -INF, -INF});
for (int &i : dp[0])
i = 0;
for (int i = 1; i < N + 1; i++) {
int a[3];
cin >> a[0] >> a[1] >> a[2];
dp[i][0] = max(dp[i - 1][1] + a[1], dp[i - 1][2] + a[2]);
dp[i][1] = max(dp[i - 1][0] + a[0], dp[i - 1][2] + a[2]);
dp[i][2] = max(dp[i - 1][0] + a[0], dp[i - 1][1] + a[1]);
}
cout << *(max_element(dp[N].begin(), dp[N].end())) << endl;
} | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 963,737 | 963,738 | u777258731 | cpp |
p03161 | #include <bits/stdc++.h>
#define F first
#define S second
#define mp make_pair
#define pb push_back
#define ll long long
#define LEFT(a) ((a) << 1)
#define RIGHT(a) (LEFT(a) + 1)
#define MID(a, b) ((a + b) >> 1)
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define MIN(a, b) ((a) < (b) ? (a) : (b))
using namespace std;
const ll N = 3e5 + 5;
int n, k;
int a[N];
int dp[N];
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
for (int i = 1; i <= n; i++)
cin >> a[i];
dp[1] = 0;
for (int i = 2; i <= n; i++) {
dp[i] = dp[i - 1] + abs(a[i] - a[i - 1]);
for (int j = i - 2; j >= i - k; j--)
dp[i] = min(dp[i], dp[j] + abs(a[i] - a[j]));
}
cout << dp[n] << endl;
return 0;
}
| #include <bits/stdc++.h>
#define F first
#define S second
#define mp make_pair
#define pb push_back
#define ll long long
#define LEFT(a) ((a) << 1)
#define RIGHT(a) (LEFT(a) + 1)
#define MID(a, b) ((a + b) >> 1)
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define MIN(a, b) ((a) < (b) ? (a) : (b))
using namespace std;
const ll N = 3e5 + 5;
int n, k;
int a[N];
int dp[N];
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
for (int i = 1; i <= n; i++)
cin >> a[i];
dp[1] = 0;
for (int i = 2; i <= n; i++) {
dp[i] = dp[i - 1] + abs(a[i] - a[i - 1]);
for (int j = i - 2; j >= i - k && j >= 1; j--)
dp[i] = min(dp[i], dp[j] + abs(a[i] - a[j]));
}
cout << dp[n] << endl;
return 0;
}
| [
"control_flow.loop.for.condition.change"
] | 963,743 | 963,744 | u704324882 | cpp |
p03161 | #include <algorithm>
#include <cstdio>
#include <vector>
using namespace std;
int n, dp[100005], a[100005], k;
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 2; i <= n; i++) {
dp[i] = dp[i - 1] + abs(a[i] - a[i - 1]);
for (int j = i - k; j < i; j++) {
dp[i] = min(dp[i], dp[j] + abs(a[i] - a[j]));
}
}
printf("%d\n", dp[n]);
return 0;
} | #include <algorithm>
#include <cstdio>
#include <vector>
using namespace std;
int n, dp[100005], a[100005], k;
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 2; i <= n; i++) {
dp[i] = dp[i - 1] + abs(a[i] - a[i - 1]);
for (int j = max(1, i - k); j < i; j++) {
dp[i] = min(dp[i], dp[j] + abs(a[i] - a[j]));
}
}
printf("%d\n", dp[n]);
return 0;
} | [
"control_flow.loop.for.initializer.change",
"call.add",
"call.arguments.change"
] | 963,748 | 963,749 | u600091451 | cpp |
p03161 | #include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
const int maxn = 100002;
int n, k, h[maxn], f[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k;
for (int i = 0; i < n; ++i)
cin >> h[i];
f[0] = 0;
for (int i = 1; i < n; ++i) {
f[i] = f[i - 1] + abs(h[i] - h[i - 1]);
for (int j = 2; j <= k; ++j)
f[i] = min(f[i], f[i - j] + abs(h[i] - h[i - j]));
}
cout << f[n - 1] << endl;
return 0;
} | #include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
const int maxn = 100002;
int n, k, h[maxn], f[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k;
for (int i = 0; i < n; ++i)
cin >> h[i];
f[0] = 0;
for (int i = 1; i < n; ++i) {
f[i] = f[i - 1] + abs(h[i] - h[i - 1]);
for (int j = 2; j <= k && j <= i; ++j)
f[i] = min(f[i], f[i - j] + abs(h[i] - h[i - j]));
}
cout << f[n - 1] << endl;
return 0;
} | [
"control_flow.loop.for.condition.change"
] | 963,750 | 963,751 | u499373855 | cpp |
p03162 | #define _CRT_SECURE_NO_WARINGS
#include <algorithm>
#include <bitset>
#include <cmath>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
typedef int me;
typedef long long ll;
typedef unsigned long long ull;
#define andrew \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define endl '\n'
#define sz(v) (int)(v.size())
#define all(v) v.begin(), v.end()
#define PI 3.1415926535
#define sin(i) (long double)sin(i *PI / 180.0)
#define cos(i) (long double)cos(i *PI / 180.0)
ll gcd(ll x, ll y) { return (y == 0) ? x : gcd(y, x % y); }
ull lcm(ll x, ll y) { return x / gcd(x, y) * y; }
int dy8[] = {0, 0, 1, -1, 1, -1, -1, 1};
int dx8[] = {1, -1, 0, 0, 1, -1, 1, -1};
int id8[] = {0, 1, 2, 3, 4, 5, 6, 7};
struct happy {
int a, b, c;
};
int n;
vector<happy> v;
ll mem[100005][4];
ll solve(int i, int last) {
if (i == n)
return 0;
ll &ret = mem[i][last];
if (ret != -1)
return ret;
if (last != 1)
ret = max(ret, solve(i + 1, 1) + v[i].a);
if (last != 2)
ret = max(ret, solve(i + 1, 2) + v[i].b);
if (last != 3)
ret = max(ret, solve(i + 1, 3) + v[i].c);
return ret;
}
int main() {
andrew;
cin >> n;
v.resize(n + 1);
for (int i = 1; i <= n; i++)
cin >> v[i].a >> v[i].b >> v[i].c;
for (int i = 0; i < 100005; i++)
for (int j = 0; j < 4; j++)
mem[i][j] = -1;
cout << solve(0, 0) << endl;
}
| #define _CRT_SECURE_NO_WARINGS
#include <algorithm>
#include <bitset>
#include <cmath>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
typedef int me;
typedef long long ll;
typedef unsigned long long ull;
#define andrew \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define endl '\n'
#define sz(v) (int)(v.size())
#define all(v) v.begin(), v.end()
#define PI 3.1415926535
#define sin(i) (long double)sin(i *PI / 180.0)
#define cos(i) (long double)cos(i *PI / 180.0)
ll gcd(ll x, ll y) { return (y == 0) ? x : gcd(y, x % y); }
ull lcm(ll x, ll y) { return x / gcd(x, y) * y; }
int dy8[] = {0, 0, 1, -1, 1, -1, -1, 1};
int dx8[] = {1, -1, 0, 0, 1, -1, 1, -1};
int id8[] = {0, 1, 2, 3, 4, 5, 6, 7};
struct happ {
int a, b, c;
};
int n;
vector<happ> v;
ll mem[100005][4];
ll solve(int i, int last) {
if (i == n + 1)
return 0;
ll &ret = mem[i][last];
if (ret != -1)
return ret;
if (last != 1)
ret = max(ret, solve(i + 1, 1) + v[i].a);
if (last != 2)
ret = max(ret, solve(i + 1, 2) + v[i].b);
if (last != 3)
ret = max(ret, solve(i + 1, 3) + v[i].c);
return ret;
}
int main() {
andrew;
cin >> n;
v.resize(n + 1);
for (int i = 1; i <= n; i++)
cin >> v[i].a >> v[i].b >> v[i].c;
for (int i = 0; i < 100005; i++)
for (int j = 0; j < 4; j++)
mem[i][j] = -1;
cout << solve(0, 0) << endl;
}
| [
"control_flow.branch.if.condition.change"
] | 963,754 | 963,755 | u816631826 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
const int mx = 1e5 + 123;
int dp[mx][4], n;
int a[mx][4];
int solve(int i, int f1) {
if (i > n)
return 0;
if (dp[i][f1] != -1)
return dp[i][f1];
int ret = 0;
for (int j = 1; j <= n; j++) {
if (j != f1) {
ret = max(ret, a[i][j] + solve(i + 1, j));
}
}
return dp[i][f1] = ret;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i][1] >> a[i][2] >> a[i][3];
memset(dp, -1, sizeof(dp));
cout << solve(0, 0) << endl;
} | #include <bits/stdc++.h>
using namespace std;
const int mx = 1e5 + 123;
int dp[mx][4], n;
int a[mx][4];
int solve(int i, int f1) {
if (i > n)
return 0;
if (dp[i][f1] != -1)
return dp[i][f1];
int ret = 0;
for (int j = 1; j <= 3; j++) {
if (j != f1) {
ret = max(ret, a[i][j] + solve(i + 1, j));
}
}
return dp[i][f1] = ret;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i][1] >> a[i][2] >> a[i][3];
memset(dp, -1, sizeof(dp));
cout << solve(0, 0) << endl;
} | [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 963,771 | 963,772 | u724640452 | cpp |
p03162 | // Alisher_2211
#include <bits/stdc++.h>
#define long long long
#define all(vc) vc.begin(), vc.end()
#define allr(vc) vc.rbegin(), vc.rend()
#define pb push_back
#define fi first
#define se second
#define pi pair<long, long>
#define lcm(a, b) (a * b) / __gcd(a, b)
using namespace std;
const long N = 100100;
void read() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
long dp[N][3];
long n, k;
void solve() {
cin >> n;
long ar[n + 5][5];
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < 3; ++j) {
cin >> ar[i][j];
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < 3; ++j) {
if (!j)
dp[i][0] = max(dp[i - 1][1], dp[i - 1][2]) + ar[i][0];
if (j == 1)
dp[i][1] = max(dp[i - 1][0], dp[i - 1][2]) + ar[i][1];
else
dp[i][2] = max(dp[i - 2][1], dp[i - 1][0]) + ar[i][2]; // <=
}
}
cout << max({dp[n][0], dp[n][1], dp[n][2]});
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long T = 1;
// cin >> T;
while (T--) {
solve();
cout << '\n';
}
cerr << "\nTime elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
} | // Alisher_2211
#include <bits/stdc++.h>
#define long long long
#define all(vc) vc.begin(), vc.end()
#define allr(vc) vc.rbegin(), vc.rend()
#define pb push_back
#define fi first
#define se second
#define pi pair<long, long>
#define lcm(a, b) (a * b) / __gcd(a, b)
using namespace std;
const long N = 100100;
void read() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
long dp[N][3];
long n, k;
void solve() {
cin >> n;
long ar[n + 5][5];
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < 3; ++j) {
cin >> ar[i][j];
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < 3; ++j) {
if (!j)
dp[i][0] = max(dp[i - 1][1], dp[i - 1][2]) + ar[i][0];
if (j == 1)
dp[i][1] = max(dp[i - 1][0], dp[i - 1][2]) + ar[i][1];
else
dp[i][2] = max(dp[i - 1][1], dp[i - 1][0]) + ar[i][2]; // <=
}
}
cout << max({dp[n][0], dp[n][1], dp[n][2]});
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long T = 1;
// cin >> T;
while (T--) {
solve();
cout << '\n';
}
cerr << "\nTime elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
} | [
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 963,773 | 963,774 | u863370423 | cpp |
p03162 | // Alisher_2211
#include <bits/stdc++.h>
#define long long long
#define all(vc) vc.begin(), vc.end()
#define allr(vc) vc.rbegin(), vc.rend()
#define pb push_back
#define fi first
#define se second
#define pi pair<long, long>
#define lcm(a, b) (a * b) / __gcd(a, b)
using namespace std;
const long N = 100100;
void read() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
long dp[N][3];
long n, k;
void solve() {
cin >> n;
long ar[n + 5][5];
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < 3; ++j) {
cin >> ar[i][j];
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < 3; ++j) {
if (!j)
dp[i][0] = max(dp[i - 1][1], dp[i - 1][2]) + ar[i][0];
if (j == 1)
dp[i][1] = max(dp[i - 1][0], dp[i - 1][2]) + ar[i][1];
else
dp[i][2] = max(dp[i][1], dp[i - 1][0]) + ar[i][2]; // <=
}
}
cout << max({dp[n][0], dp[n][1], dp[n][2]});
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long T = 1;
// cin >> T;
while (T--) {
solve();
cout << '\n';
}
cerr << "\nTime elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
} | // Alisher_2211
#include <bits/stdc++.h>
#define long long long
#define all(vc) vc.begin(), vc.end()
#define allr(vc) vc.rbegin(), vc.rend()
#define pb push_back
#define fi first
#define se second
#define pi pair<long, long>
#define lcm(a, b) (a * b) / __gcd(a, b)
using namespace std;
const long N = 100100;
void read() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
long dp[N][3];
long n, k;
void solve() {
cin >> n;
long ar[n + 5][5];
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < 3; ++j) {
cin >> ar[i][j];
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < 3; ++j) {
if (!j)
dp[i][0] = max(dp[i - 1][1], dp[i - 1][2]) + ar[i][0];
if (j == 1)
dp[i][1] = max(dp[i - 1][0], dp[i - 1][2]) + ar[i][1];
else
dp[i][2] = max(dp[i - 1][1], dp[i - 1][0]) + ar[i][2]; // <=
}
}
cout << max({dp[n][0], dp[n][1], dp[n][2]});
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long T = 1;
// cin >> T;
while (T--) {
solve();
cout << '\n';
}
cerr << "\nTime elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
} | [
"assignment.change"
] | 963,775 | 963,774 | u863370423 | cpp |
p03162 | #define _CRT_SECURE_NO_WARNINGS
#include <bits/stdc++.h>
#include <unordered_map>
#define stop(x) \
{ \
cout << x << endl; \
exit(0); \
}
#define all(x) x.begin(), x.end()
#define szz(s) int(s.size())
#define endl '\n'
int dx[] = {0, 0, 1, -1, 1, -1, 1, -1};
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
typedef long long ll;
using namespace std;
void file() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
#ifndef ONLINE_JUDGE
if (freopen("input.txt", "r", stdin))
;
if (freopen("output.txt", "w", stdout))
;
#endif
}
int n;
ll mem[100004][4];
vector<vector<int>> v;
ll solve(int idx, int last) {
if (idx == n)
return 0;
ll &ret = mem[idx][last];
if (~ret)
return ret;
ret = 0;
if (last != 0)
ret = max(ret, solve(idx + 1, 0) + v[idx][0]);
if (last != 1)
ret = max(ret, solve(idx + 1, 1) + v[idx][1]);
if (last != 2)
ret = max(ret, solve(idx + 1, 2) + v[idx][2]);
return ret;
}
int main() {
file();
memset(mem, -1, sizeof mem);
cin >> n;
v = vector<vector<int>>(n, vector<int>(3));
for (auto &e : v)
for (auto &f : e)
cin >> f;
cout << solve(0, 4) << endl;
} | #define _CRT_SECURE_NO_WARNINGS
#include <bits/stdc++.h>
#include <unordered_map>
#define stop(x) \
{ \
cout << x << endl; \
exit(0); \
}
#define all(x) x.begin(), x.end()
#define szz(s) int(s.size())
#define endl '\n'
int dx[] = {0, 0, 1, -1, 1, -1, 1, -1};
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
typedef long long ll;
using namespace std;
void file() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
#ifndef ONLINE_JUDGE
if (freopen("input.txt", "r", stdin))
;
if (freopen("output.txt", "w", stdout))
;
#endif
}
ll n;
ll mem[100004][4];
vector<vector<int>> v;
ll solve(int idx, int last) {
if (idx == n)
return 0;
ll &ret = mem[idx][last];
if (~ret)
return ret;
ret = 0;
if (last != 0)
ret = max(ret, solve(idx + 1, 0) + v[idx][0]);
if (last != 1)
ret = max(ret, solve(idx + 1, 1) + v[idx][1]);
if (last != 2)
ret = max(ret, solve(idx + 1, 2) + v[idx][2]);
return ret;
}
int main() {
// file();
memset(mem, -1, sizeof mem);
cin >> n;
v = vector<vector<int>>(n, vector<int>(3));
for (auto &e : v)
for (auto &f : e)
cin >> f;
cout << solve(0, 3) << endl;
} | [
"variable_declaration.type.change",
"call.remove",
"literal.number.change",
"io.output.change"
] | 963,780 | 963,779 | u018679195 | cpp |
p03162 | #include <bits/stdc++.h>
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define erep(i, n) for (ll i = 1; i <= (n); i++)
#define maxs(x, y) (x = max(x, y))
#define mins(x, y) (x = min(x, y))
using namespace std;
using ll = long long;
const ll INF = 1LL << 60;
// input
ll h[100010][3];
// dp table
ll dp[100010][3];
int main(void) {
int n;
cin >> n;
rep(i, n) rep(j, n) cin >> h[i][j];
rep(i, n) rep(j, 3) rep(k, 3) if (j != k) {
maxs(dp[i + 1][j], dp[i][k] + h[i][j]);
}
ll ans = 0;
rep(i, 3) maxs(ans, dp[n][i]);
cout << ans << '\n';
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define erep(i, n) for (ll i = 1; i <= (n); i++)
#define maxs(x, y) (x = max(x, y))
#define mins(x, y) (x = min(x, y))
using namespace std;
using ll = long long;
const ll INF = 1LL << 60;
// input
ll h[100010][3];
// dp table
ll dp[100010][3];
int main(void) {
int n;
cin >> n;
rep(i, n) rep(j, 3) cin >> h[i][j];
rep(i, n) rep(j, 3) rep(k, 3) if (j != k) {
maxs(dp[i + 1][j], dp[i][k] + h[i][j]);
}
ll ans = 0;
rep(i, 3) maxs(ans, dp[n][i]);
cout << ans << '\n';
return 0;
} | [
"identifier.replace.remove",
"literal.replace.add",
"call.arguments.change"
] | 963,785 | 963,786 | u732854336 | cpp |
p03162 | #pragma GCC optimize("O3")
#define _GLIBCXX_DEBUG
#include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <string_view>
#include <vector>
using namespace std;
/*----------macros----------*/
// output================
#define endl '\n'
#define fcout(a) cout << fixed << setprecision((int)(a))
// typedef===============
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<ll, ll> Pll;
// const number==========
constexpr ll INF9 = (ll)1e9 + 1;
constexpr ll INF18 = (ll)1e18 + 1;
constexpr ll MOD = 1000000007;
constexpr ll MOD2 = 998244353;
constexpr ld PI = 3.141592653589793L;
// member================
#define pb push_back
#define eb emplace_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
// others================
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define rep(i, n) for (int i = 0; (i) < (n); ++(i))
#define reps(i, n) for (int i = 1; (i) <= (n); ++(i))
#define rrep(i, n) for (int i = n - 1; (i) >= 0; --(i))
#define CtoI(c) int((c)) - int('0')
#define ItoC(c) char((c) + '0')
// functions=============
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
// vector<int> dx = {1, 0, -1, 0}, dy = {0, 1, 0, -1};
// vector<int> dx2 = { 1,1,0,-1,-1,-1,0,1 }, dy2 = { 0,1,1,1,0,-1,-1,-1 };
/*--------additional--------*/
/*----------main------------*/
int main() {
/*----------fastio----------*/
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::ios::sync_with_stdio(false);
/*----------solve-----------*/
int n;
cin >> n;
vector<int> a(n), b(n), c(n);
rep(i, n) cin >> a[i] >> b[i] >> c[i];
int dp[n + 100][3];
for (int i = 1; i <= n; ++i) {
dp[i][0] = max(dp[i - 1][1] + b[i - 1], dp[i - 1][2] + c[i - 1]);
dp[i][1] = max(dp[i - 1][0] + a[i - 1], dp[i - 1][2] + c[i - 1]);
dp[i][2] = max(dp[i - 1][0] + a[i - 1], dp[i - 1][1] + b[i - 1]);
}
cout << max(dp[n][0], max(dp[n][1], dp[n][2])) << endl;
return 0;
} | #pragma GCC optimize("O3")
#define _GLIBCXX_DEBUG
#include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <string_view>
#include <vector>
using namespace std;
/*----------macros----------*/
// output================
#define endl '\n'
#define fcout(a) cout << fixed << setprecision((int)(a))
// typedef===============
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<ll, ll> Pll;
// const number==========
constexpr ll INF9 = (ll)1e9 + 1;
constexpr ll INF18 = (ll)1e18 + 1;
constexpr ll MOD = 1000000007;
constexpr ll MOD2 = 998244353;
constexpr ld PI = 3.141592653589793L;
// member================
#define pb push_back
#define eb emplace_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
// others================
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define rep(i, n) for (int i = 0; (i) < (n); ++(i))
#define reps(i, n) for (int i = 1; (i) <= (n); ++(i))
#define rrep(i, n) for (int i = n - 1; (i) >= 0; --(i))
#define CtoI(c) int((c)) - int('0')
#define ItoC(c) char((c) + '0')
// functions=============
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
// vector<int> dx = {1, 0, -1, 0}, dy = {0, 1, 0, -1};
// vector<int> dx2 = { 1,1,0,-1,-1,-1,0,1 }, dy2 = { 0,1,1,1,0,-1,-1,-1 };
/*--------additional--------*/
/*----------main------------*/
int main() {
/*----------fastio----------*/
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::ios::sync_with_stdio(false);
/*----------solve-----------*/
int n;
cin >> n;
vector<int> a(n), b(n), c(n);
rep(i, n) cin >> a[i] >> b[i] >> c[i];
int dp[n + 1000][3];
for (int i = 1; i <= n; ++i) {
dp[i][0] = max(dp[i - 1][1] + b[i - 1], dp[i - 1][2] + c[i - 1]);
dp[i][1] = max(dp[i - 1][0] + a[i - 1], dp[i - 1][2] + c[i - 1]);
dp[i][2] = max(dp[i - 1][0] + a[i - 1], dp[i - 1][1] + b[i - 1]);
}
cout << max(dp[n][0], max(dp[n][1], dp[n][2])) << endl;
return 0;
} | [
"literal.number.change",
"expression.operation.binary.change"
] | 963,789 | 963,790 | u884476319 | cpp |
p03162 | #pragma GCC optimize("O3")
#define _GLIBCXX_DEBUG
#include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <string_view>
#include <vector>
using namespace std;
/*----------macros----------*/
// output================
#define endl '\n'
#define fcout(a) cout << fixed << setprecision((int)(a))
// typedef===============
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<ll, ll> Pll;
// const number==========
constexpr ll INF9 = (ll)1e9 + 1;
constexpr ll INF18 = (ll)1e18 + 1;
constexpr ll MOD = 1000000007;
constexpr ll MOD2 = 998244353;
constexpr ld PI = 3.141592653589793L;
// member================
#define pb push_back
#define eb emplace_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
// others================
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define rep(i, n) for (int i = 0; (i) < (n); ++(i))
#define reps(i, n) for (int i = 1; (i) <= (n); ++(i))
#define rrep(i, n) for (int i = n - 1; (i) >= 0; --(i))
#define CtoI(c) int((c)) - int('0')
#define ItoC(c) char((c) + '0')
// functions=============
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
// vector<int> dx = {1, 0, -1, 0}, dy = {0, 1, 0, -1};
// vector<int> dx2 = { 1,1,0,-1,-1,-1,0,1 }, dy2 = { 0,1,1,1,0,-1,-1,-1 };
/*--------additional--------*/
/*----------main------------*/
int main() {
/*----------fastio----------*/
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::ios::sync_with_stdio(false);
/*----------solve-----------*/
int n;
cin >> n;
vector<int> a(n), b(n), c(n);
rep(i, n) cin >> a[i] >> b[i] >> c[i];
int dp[n + 10][3];
for (int i = 1; i <= n; ++i) {
dp[i][0] = max(dp[i - 1][1] + b[i - 1], dp[i - 1][2] + c[i - 1]);
dp[i][1] = max(dp[i - 1][0] + a[i - 1], dp[i - 1][2] + c[i - 1]);
dp[i][2] = max(dp[i - 1][0] + a[i - 1], dp[i - 1][1] + b[i - 1]);
}
cout << max(dp[n][0], max(dp[n][1], dp[n][2])) << endl;
return 0;
} | #pragma GCC optimize("O3")
#define _GLIBCXX_DEBUG
#include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <string_view>
#include <vector>
using namespace std;
/*----------macros----------*/
// output================
#define endl '\n'
#define fcout(a) cout << fixed << setprecision((int)(a))
// typedef===============
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<ll, ll> Pll;
// const number==========
constexpr ll INF9 = (ll)1e9 + 1;
constexpr ll INF18 = (ll)1e18 + 1;
constexpr ll MOD = 1000000007;
constexpr ll MOD2 = 998244353;
constexpr ld PI = 3.141592653589793L;
// member================
#define pb push_back
#define eb emplace_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
// others================
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define rep(i, n) for (int i = 0; (i) < (n); ++(i))
#define reps(i, n) for (int i = 1; (i) <= (n); ++(i))
#define rrep(i, n) for (int i = n - 1; (i) >= 0; --(i))
#define CtoI(c) int((c)) - int('0')
#define ItoC(c) char((c) + '0')
// functions=============
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
// vector<int> dx = {1, 0, -1, 0}, dy = {0, 1, 0, -1};
// vector<int> dx2 = { 1,1,0,-1,-1,-1,0,1 }, dy2 = { 0,1,1,1,0,-1,-1,-1 };
/*--------additional--------*/
/*----------main------------*/
int main() {
/*----------fastio----------*/
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::ios::sync_with_stdio(false);
/*----------solve-----------*/
int n;
cin >> n;
vector<int> a(n), b(n), c(n);
rep(i, n) cin >> a[i] >> b[i] >> c[i];
int dp[n + 1000][3];
for (int i = 1; i <= n; ++i) {
dp[i][0] = max(dp[i - 1][1] + b[i - 1], dp[i - 1][2] + c[i - 1]);
dp[i][1] = max(dp[i - 1][0] + a[i - 1], dp[i - 1][2] + c[i - 1]);
dp[i][2] = max(dp[i - 1][0] + a[i - 1], dp[i - 1][1] + b[i - 1]);
}
cout << max(dp[n][0], max(dp[n][1], dp[n][2])) << endl;
return 0;
} | [
"literal.number.change",
"expression.operation.binary.change"
] | 963,791 | 963,790 | u884476319 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
vector<int> a(3);
cin >> n;
int dp[3][n];
int ans = 0;
for (int i{}; i < 3; i++) {
cin >> a[i];
dp[i][0] = a[i];
ans = max(ans, a[i]);
}
if (n == 1) {
cout << ans << endl;
return 0;
}
n--;
for (int i{1}; i < n; i++) {
for (auto &x : a) {
cin >> x;
}
dp[0][i] = max(dp[1][i - 1], dp[2][i - 1]) + a[0];
dp[1][i] = max(dp[0][i - 1], dp[2][i - 1]) + a[1];
dp[2][i] = max(dp[0][i - 1], dp[1][i - 1]) + a[2];
}
cout << max(max(dp[0][n - 1], dp[1][n - 1]), max(dp[0][n - 1], dp[2][n - 1]));
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
vector<int> a(3);
cin >> n;
int dp[3][n];
int ans = 0;
for (int i{}; i < 3; i++) {
cin >> a[i];
dp[i][0] = a[i];
ans = max(ans, a[i]);
}
if (n == 1) {
cout << ans << endl;
return 0;
}
// n--;
for (int i{1}; i < n; i++) {
for (auto &x : a) {
cin >> x;
}
dp[0][i] = max(dp[1][i - 1], dp[2][i - 1]) + a[0];
dp[1][i] = max(dp[0][i - 1], dp[2][i - 1]) + a[1];
dp[2][i] = max(dp[0][i - 1], dp[1][i - 1]) + a[2];
}
cout << max(max(dp[0][n - 1], dp[1][n - 1]), max(dp[0][n - 1], dp[2][n - 1]));
}
| [
"expression.unary.arithmetic.remove"
] | 963,795 | 963,796 | u752124256 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
struct iofix {
ios_base::Init i;
iofix() {
cin.sync_with_stdio(0);
cin.tie(0);
cout.sync_with_stdio(0);
cout.tie(0);
cout.precision(10);
cout << fixed;
}
} iofix;
void solve() {
int N;
cin >> N;
vector<int64_t> dp(3, 0);
for (int i = 0; i < N; ++i) {
vector<int64_t> cost(3);
for (int c = 0; c < N; ++c)
cin >> cost[c];
vector<int64_t> new_dp(3, 0);
for (int j = 0; j < 3; ++j) {
for (int k = 0; k < 3; ++k) {
if (j != k)
new_dp[k] = max(new_dp[k], dp[j] + cost[k]);
}
}
dp = new_dp;
}
cout << max({dp[0], dp[1], dp[2]}) << "\n";
}
int main() {
solve();
#ifndef Time
cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
struct iofix {
ios_base::Init i;
iofix() {
cin.sync_with_stdio(0);
cin.tie(0);
cout.sync_with_stdio(0);
cout.tie(0);
cout.precision(10);
cout << fixed;
}
} iofix;
void solve() {
int N;
cin >> N;
vector<int64_t> dp(3, 0);
for (int i = 0; i < N; ++i) {
vector<int64_t> cost(3);
for (int c = 0; c < 3; ++c)
cin >> cost[c];
vector<int64_t> new_dp(3, 0);
for (int j = 0; j < 3; ++j) {
for (int k = 0; k < 3; ++k) {
if (j != k)
new_dp[k] = max(new_dp[k], dp[j] + cost[k]);
}
}
dp = new_dp;
}
cout << max({dp[0], dp[1], dp[2]}) << "\n";
}
int main() {
solve();
#ifndef Time
cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
return 0;
}
| [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 963,801 | 963,802 | u649291993 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
struct iofix {
ios_base::Init i;
iofix() {
cin.sync_with_stdio(0);
cin.tie(0);
cout.sync_with_stdio(0);
cout.tie(0);
cout.precision(10);
cout << fixed;
}
} iofix;
void solve() {
int N;
cin >> N;
vector<int64_t> dp(3);
for (int i = 0; i < N; ++i) {
vector<int64_t> cost(3);
for (int c = 0; c < N; ++c)
cin >> cost[c];
vector<int64_t> new_dp(3);
for (int j = 0; j < 3; ++j) {
for (int k = 0; k < 3; ++k) {
if (j != k)
new_dp[k] = max(new_dp[k], dp[j] + cost[k]);
}
}
dp = new_dp;
}
cout << max({dp[0], dp[1], dp[2]}) << "\n";
}
int main() {
solve();
#ifndef Time
cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
struct iofix {
ios_base::Init i;
iofix() {
cin.sync_with_stdio(0);
cin.tie(0);
cout.sync_with_stdio(0);
cout.tie(0);
cout.precision(10);
cout << fixed;
}
} iofix;
void solve() {
int N;
cin >> N;
vector<int64_t> dp(3, 0);
for (int i = 0; i < N; ++i) {
vector<int64_t> cost(3);
for (int c = 0; c < 3; ++c)
cin >> cost[c];
vector<int64_t> new_dp(3, 0);
for (int j = 0; j < 3; ++j) {
for (int k = 0; k < 3; ++k) {
if (j != k)
new_dp[k] = max(new_dp[k], dp[j] + cost[k]);
}
}
dp = new_dp;
}
cout << max({dp[0], dp[1], dp[2]}) << "\n";
}
int main() {
solve();
#ifndef Time
cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
return 0;
}
| [
"call.arguments.add",
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 963,803 | 963,802 | u649291993 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(void) {
int N;
cin >> N;
ll a[110000][3];
ll dp[110000][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 < N; k++) {
if (j == k)
continue;
dp[i + 1][k] = max(dp[i + 1][k], dp[i][j] + a[i][k]);
}
}
}
ll 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;
typedef long long ll;
int main(void) {
int N;
cin >> N;
ll a[110000][3];
ll dp[110000][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]);
}
}
}
ll res = 0;
for (int j = 0; j < 3; j++) {
res = max(res, dp[N][j]);
}
cout << res << endl;
} | [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 963,806 | 963,807 | u883680855 | cpp |
p03162 | #include <cstdlib>
#include <iostream>
#include <vector>
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 long long INF = 1LL << 60;
// 入力
int N;
long long h[100010][3];
// DP テーブル
long long dp[100010][3] = {};
int main() {
int N;
cin >> N;
for (int i = 0; i < N; ++i)
for (int j = 0; j < N; j++)
cin >> h[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;
chmax(dp[i + 1][k], dp[i][j] + h[i][k]); // dp[1][]には1日目の結果…
}
}
}
// 答え
cout << max(dp[N][0], max(dp[N][1], dp[N][2])) << endl;
} | #include <cstdlib>
#include <iostream>
#include <vector>
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 long long INF = 1LL << 60;
// 入力
int N;
long long h[100010][3];
// DP テーブル
long long dp[100010][3] = {};
int main() {
int N;
cin >> N;
for (int i = 0; i < N; ++i)
for (int j = 0; j < 3; j++)
cin >> h[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;
chmax(dp[i + 1][k], dp[i][j] + h[i][k]); // dp[1][]には1日目の結果…
}
}
}
// 答え
cout << max(dp[N][0], max(dp[N][1], dp[N][2])) << endl;
} | [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 963,814 | 963,815 | u625417564 | cpp |
p03162 | #include <cstdlib>
#include <iostream>
#include <vector>
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 long long INF = 1LL << 60;
// 入力
int N;
long long h[100010][3];
// DP テーブル
long long dp[100010][3] = {};
int main() {
int N;
cin >> N;
for (int i = 0; i < N; ++i)
for (int j = 0; j < N; j++)
cin >> h[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;
chmax(dp[i + 1][k], dp[i][j] + h[i][k]); // dp[1][]には1日目の結果…
}
}
}
// 答え
cout << max(dp[N][1], max(dp[N][2], dp[N][3])) << endl;
} | #include <cstdlib>
#include <iostream>
#include <vector>
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 long long INF = 1LL << 60;
// 入力
int N;
long long h[100010][3];
// DP テーブル
long long dp[100010][3] = {};
int main() {
int N;
cin >> N;
for (int i = 0; i < N; ++i)
for (int j = 0; j < 3; j++)
cin >> h[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;
chmax(dp[i + 1][k], dp[i][j] + h[i][k]); // dp[1][]には1日目の結果…
}
}
}
// 答え
cout << max(dp[N][0], max(dp[N][1], dp[N][2])) << endl;
} | [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"literal.number.change",
"variable_access.subscript.index.change",
"io.output.change"
] | 963,816 | 963,815 | u625417564 | cpp |
p03162 | #include <iostream>
#define N 3
#define loop(i, n) for (int i = 0; i < n; i++)
using namespace std;
int a[100002][N];
int dp[100002][N + 1];
int n;
int min_cost(int n, int c) {
if (n == 0)
return 0;
if (dp[n][c] != -1)
return dp[n][c];
int ans = 0;
for (int i = 0; i <= 2; i++)
if (c == 3)
ans = max(ans, a[n - 1][i] + min_cost(n - 1, i));
else if (c != i)
ans = max(ans, a[n - 1][i] + min_cost(n - 1, i));
return dp[n][c] = ans;
}
int main() {
cin >> n;
loop(i, n) loop(j, N) cin >> a[i][j];
loop(i, n) loop(j, N + 1) dp[i][j] = -1;
cout << min_cost(n, 3) << endl;
return 0;
}
| #include <iostream>
#define N 3
#define loop(i, n) for (int i = 0; i < n; i++)
using namespace std;
int a[100002][N];
int dp[100002][N + 1];
int n;
int min_cost(int n, int c) {
if (n == 0)
return 0;
if (dp[n][c] != -1)
return dp[n][c];
int ans = 0;
for (int i = 0; i <= 2; i++)
if (c == 3)
ans = max(ans, a[n - 1][i] + min_cost(n - 1, i));
else if (c != i)
ans = max(ans, a[n - 1][i] + min_cost(n - 1, i));
return dp[n][c] = ans;
}
int main() {
cin >> n;
loop(i, n) loop(j, N) cin >> a[i][j];
loop(i, n + 1) loop(j, N + 1) dp[i][j] = -1;
cout << min_cost(n, 3) << endl;
return 0;
}
| [
"expression.operation.binary.add"
] | 963,823 | 963,824 | u775778491 | cpp |
p03162 | #include <bits/stdc++.h>
#include <cctype>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define ll long long int
#define ld long double
#define PRY cout << "YES\n"
#define PRN cout << "NO\n"
#define SETP(sp) fixed << setprecision(sp)
#define PB push_back
#define GO \
ll t; \
cin >> t; \
while (t--)
#define G(t) \
cin >> t; \
while (t--)
#define ALLR(x) x.rbegin(), x.rend()
#define PII pair<ll, ll>
#define VI vector<ll>
#define ALL(a) (a).begin(), (a).end()
#define F first
#define S second
#define PI 3.141592653589793238
#define SZ(x) (ll) x.size()
#define hell9 998244353
#define hell 1000000007
#define FO(i, a, b) for (i = a; i < b; i++)
#define FOREV(i, a, b) for (i = a; i >= b; i--)
#define lbnd lower_bound
#define ubnd upper_bound
#define BS binary_search
#define MP make_pair
#define LIM 100005
#define ARR(n, i, a) \
ll n, i; \
cin >> n; \
ll a[n]; \
FO(i, 0, n) cin >> a[i];
#define ARRK(k, n, i, a) \
int n, k, i; \
scanf("%d%d", &n, &k); \
ll a[n]; \
FO(i, 0, n) scanf("%lld", &a[i]);
#define fio \
ios_base::sync_with_stdio(false); \
cin.tie(0);
using namespace std;
using namespace __gnu_pbds;
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
ord_set;
/*ll powM(ll x, ll y, ll p)
{
ll res = 1;
x = x % p;
while (y > 0)
{
if (y & 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}/*
ll POW(ll x, ll y)
{
ll res = 1;
while (y > 0)
{
if (y & 1)
res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
int LIS(std::vector<int>& v)
{
if (v.size() == 0)
return 0;
std::vector<int> tail(v.size(), 0);
int length = 1;
tail[0] = v[0];
for (int i = 1; i < v.size(); i++)
{
auto b = tail.begin(), e = tail.begin() + length;
auto it = lower_bound(b, e, v[i]);
if (it == tail.begin() + length)
tail[length++] = v[i];
else
*it = v[i];
}
return length;
}
ll modInverse(ll n, ll p)
{
return powM(n, p - 2, p);
}
/*
ll fac[500000] = {0};
ll done = 1;
ncrModP(ll n, ll r, ll p)
{
if (r == 0)
return 1;
fac[0] = 1;
if (n > done)
{ for (ll i = done ; i <= n; i++)
fac[i] = (fac[i - 1] * i) % p;
}
done = max(done, n);
return (fac[n] * modInverse(fac[r], p) % p *
modInverse(fac[n - r], p) % p) % p;
}
ll ncrM(ll n, ll r)
{
if (r > n - r)
r = n - r;
ll C[r + 1];
memset(C, 0, sizeof(C));
C[0] = 1;
for (ll i = 1; i <= n; i++) {
for (ll j = min(i, r); j > 0; j--)
C[j] = (C[j] + C[j - 1]);
}
return C[r];
}
map<ll, ll>f;
ll fib(ll k)
{
ll i; f[0] = 1; f[1] = 1; f[2] = 2;
if (k <= done)return f[k];
for (i = done; i <= k; i++)f[i] = (f[i - 1] % hell + f[i - 2] % hell) %
hell; done = k; return f[k] % hell; }void sieve(int n)
{
bool prime[5*LIM];
memset(prime, true, sizeof(prime));
int rootn = (int)sqrt(n);
for (int p = 2; p <= rootn; p++)
if (prime[p] == true)
for (int i = p*p; i <= n; i += p)
prime[i] = false;
prime[1] = 0;
}*/
bool sortinrev(const pair<int, int> &a, const pair<int, int> &b) {
if (a.first != b.first)
return (a.first > b.first);
else
return (a.second < b.second);
} /*
int x[101];
int y[101];
bool vis[200005]={0};
int n;
int a[200005]={0};
vector<int> b[200005];
int p[200005]={0};
vector<pair<int,int> > a1,a2;
map<pair<int,int>,int >m;
char gr[51][51];
int n,c=0;
void dfs(int u,int v)
{
if(u<0||u>=n||v<0||v>=n)return;
if(m[{u,v}]!=0)return;
if(gr[u][v]=='1')return;
m[{u,v}]=c;
if(c==1)a1.PB({u,v});
if(c==2)a2.PB({u,v});
dfs(u-1,v);
dfs(u+1,v);
dfs(u,v-1);
dfs(u,v+1);
}*/
int t;
int main() {
fio
// G(t){
ll n,
i;
cin >> n;
ll a[n][3] = {0};
FO(i, 0, n)
cin >> a[i][0] >> a[i][1] >> a[i][2];
ll dp[n + 1][3] = {0};
FO(i, 1, n + 1) {
dp[i][0] = max(dp[i - 1][1], dp[i - 1][2]) + a[i - 1][0];
dp[i][1] = max(dp[i - 1][0], dp[i - 1][2]) + a[i - 1][1];
dp[i][2] = max(dp[i - 1][1], dp[i - 1][0]) + a[i - 1][2];
}
cout << max(dp[n][0], max(dp[n][1], dp[i][2]));
//}
return 0;
}
| #include <bits/stdc++.h>
#include <cctype>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define ll long long int
#define ld long double
#define PRY cout << "YES\n"
#define PRN cout << "NO\n"
#define SETP(sp) fixed << setprecision(sp)
#define PB push_back
#define GO \
ll t; \
cin >> t; \
while (t--)
#define G(t) \
cin >> t; \
while (t--)
#define ALLR(x) x.rbegin(), x.rend()
#define PII pair<ll, ll>
#define VI vector<ll>
#define ALL(a) (a).begin(), (a).end()
#define F first
#define S second
#define PI 3.141592653589793238
#define SZ(x) (ll) x.size()
#define hell9 998244353
#define hell 1000000007
#define FO(i, a, b) for (i = a; i < b; i++)
#define FOREV(i, a, b) for (i = a; i >= b; i--)
#define lbnd lower_bound
#define ubnd upper_bound
#define BS binary_search
#define MP make_pair
#define LIM 100005
#define ARR(n, i, a) \
ll n, i; \
cin >> n; \
ll a[n]; \
FO(i, 0, n) cin >> a[i];
#define ARRK(k, n, i, a) \
int n, k, i; \
scanf("%d%d", &n, &k); \
ll a[n]; \
FO(i, 0, n) scanf("%lld", &a[i]);
#define fio \
ios_base::sync_with_stdio(false); \
cin.tie(0);
using namespace std;
using namespace __gnu_pbds;
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
ord_set;
/*ll powM(ll x, ll y, ll p)
{
ll res = 1;
x = x % p;
while (y > 0)
{
if (y & 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}/*
ll POW(ll x, ll y)
{
ll res = 1;
while (y > 0)
{
if (y & 1)
res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
int LIS(std::vector<int>& v)
{
if (v.size() == 0)
return 0;
std::vector<int> tail(v.size(), 0);
int length = 1;
tail[0] = v[0];
for (int i = 1; i < v.size(); i++)
{
auto b = tail.begin(), e = tail.begin() + length;
auto it = lower_bound(b, e, v[i]);
if (it == tail.begin() + length)
tail[length++] = v[i];
else
*it = v[i];
}
return length;
}
ll modInverse(ll n, ll p)
{
return powM(n, p - 2, p);
}
/*
ll fac[500000] = {0};
ll done = 1;
ncrModP(ll n, ll r, ll p)
{
if (r == 0)
return 1;
fac[0] = 1;
if (n > done)
{ for (ll i = done ; i <= n; i++)
fac[i] = (fac[i - 1] * i) % p;
}
done = max(done, n);
return (fac[n] * modInverse(fac[r], p) % p *
modInverse(fac[n - r], p) % p) % p;
}
ll ncrM(ll n, ll r)
{
if (r > n - r)
r = n - r;
ll C[r + 1];
memset(C, 0, sizeof(C));
C[0] = 1;
for (ll i = 1; i <= n; i++) {
for (ll j = min(i, r); j > 0; j--)
C[j] = (C[j] + C[j - 1]);
}
return C[r];
}
map<ll, ll>f;
ll fib(ll k)
{
ll i; f[0] = 1; f[1] = 1; f[2] = 2;
if (k <= done)return f[k];
for (i = done; i <= k; i++)f[i] = (f[i - 1] % hell + f[i - 2] % hell) %
hell; done = k; return f[k] % hell; }void sieve(int n)
{
bool prime[5*LIM];
memset(prime, true, sizeof(prime));
int rootn = (int)sqrt(n);
for (int p = 2; p <= rootn; p++)
if (prime[p] == true)
for (int i = p*p; i <= n; i += p)
prime[i] = false;
prime[1] = 0;
}*/
bool sortinrev(const pair<int, int> &a, const pair<int, int> &b) {
if (a.first != b.first)
return (a.first > b.first);
else
return (a.second < b.second);
} /*
int x[101];
int y[101];
bool vis[200005]={0};
int n;
int a[200005]={0};
vector<int> b[200005];
int p[200005]={0};
vector<pair<int,int> > a1,a2;
map<pair<int,int>,int >m;
char gr[51][51];
int n,c=0;
void dfs(int u,int v)
{
if(u<0||u>=n||v<0||v>=n)return;
if(m[{u,v}]!=0)return;
if(gr[u][v]=='1')return;
m[{u,v}]=c;
if(c==1)a1.PB({u,v});
if(c==2)a2.PB({u,v});
dfs(u-1,v);
dfs(u+1,v);
dfs(u,v-1);
dfs(u,v+1);
}*/
int t;
int main() {
fio
// G(t){
ll n,
i;
cin >> n;
ll a[n][3] = {0};
FO(i, 0, n)
cin >> a[i][0] >> a[i][1] >> a[i][2];
ll dp[n + 1][3] = {0};
FO(i, 1, n + 1) {
dp[i][0] = max(dp[i - 1][1], dp[i - 1][2]) + a[i - 1][0];
dp[i][1] = max(dp[i - 1][0], dp[i - 1][2]) + a[i - 1][1];
dp[i][2] = max(dp[i - 1][1], dp[i - 1][0]) + a[i - 1][2];
}
cout << max(dp[n][0], max(dp[n][1], dp[n][2]));
//}
return 0;
}
| [
"identifier.change",
"variable_access.subscript.index.change",
"io.output.change"
] | 963,825 | 963,826 | u232917796 | cpp |
p03162 | // This file is a "Hello, world!" in C++ language by GCC for wandbox.
#include <algorithm>
#include <cstdlib>
#include <iostream>
#include <string>
#include <utility>
using namespace std;
int main() {
int n;
int aa, bb, cc;
cin >> n;
int a[n + 1], b[n + 1], c[n + 1];
a[0] = 0;
b[0] = 0;
c[0] = 0;
for (int i = 1; i < n + 1; i++) {
cin >> aa >> bb >> cc;
a[i] = aa;
b[i] = bb;
c[i] = cc;
}
int dp[3][n + 1];
dp[0][0] = 0;
dp[0][1] = 0;
dp[0][2] = 0;
for (int i = 1; i < n + 1; i++) {
dp[0][i] = max(dp[1][i - 1], dp[2][i - 1]) + a[i];
dp[1][i] = max(dp[0][i - 1], dp[2][i - 1]) + b[i];
dp[2][i] = max(dp[1][i - 1], dp[0][i - 1]) + c[i];
}
int ans = max(dp[0][n], dp[1][n]);
ans = max(ans, dp[2][n]);
std::cout << ans << std::endl;
}
// GCC reference:
// https://gcc.gnu.org/
// C++ language references:
// https://cppreference.com/
// https://isocpp.org/
// http://www.open-std.org/jtc1/sc22/wg21/
// Boost libraries references:
// https://www.boost.org/doc/
| // This file is a "Hello, world!" in C++ language by GCC for wandbox.
#include <algorithm>
#include <cstdlib>
#include <iostream>
#include <string>
#include <utility>
using namespace std;
int main() {
int n;
int aa, bb, cc;
cin >> n;
int a[n + 1], b[n + 1], c[n + 1];
a[0] = 0;
b[0] = 0;
c[0] = 0;
for (int i = 1; i < n + 1; i++) {
cin >> aa >> bb >> cc;
a[i] = aa;
b[i] = bb;
c[i] = cc;
}
int dp[3][n + 1];
dp[0][0] = 0;
dp[1][0] = 0;
dp[2][0] = 0;
for (int i = 1; i < n + 1; i++) {
dp[0][i] = max(dp[1][i - 1], dp[2][i - 1]) + a[i];
dp[1][i] = max(dp[0][i - 1], dp[2][i - 1]) + b[i];
dp[2][i] = max(dp[1][i - 1], dp[0][i - 1]) + c[i];
}
int ans = max(dp[0][n], dp[1][n]);
ans = max(ans, dp[2][n]);
std::cout << ans << std::endl;
}
// GCC reference:
// https://gcc.gnu.org/
// C++ language references:
// https://cppreference.com/
// https://isocpp.org/
// http://www.open-std.org/jtc1/sc22/wg21/
// Boost libraries references:
// https://www.boost.org/doc/
| [
"literal.number.change",
"assignment.variable.change",
"variable_access.subscript.index.change"
] | 963,835 | 963,836 | u693716675 | cpp |
p03162 | //~ while (clock()<=69*CLOCKS_PER_SEC)
//~ #pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("O3")
//~ #pragma GCC optimize("Ofast")
//~ #pragma GCC
//target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native") ~ #pragma
//GCC optimize("unroll-loops")
#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;
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define sim template <class c
#define ris return *this
#define dor > debug &operator<<
#define eni(x) \
sim > typename enable_if<sizeof dud<c>(0) x 1, debug &>::type operator<<( \
c i) {
sim > struct rge { c b, e; };
sim > rge<c> range(c i, c j) { return rge<c>{i, j}; }
sim > auto dud(c *x) -> decltype(cerr << *x, 0);
sim > char dud(...);
struct debug {
#ifdef LOCAL
~debug() { cerr << endl; }
eni(!=) cerr << boolalpha << i;
ris;
} eni(==) ris << range(begin(i), end(i));
}
sim, class b dor(pair<b, c> d) {
ris << "(" << d.first << ", " << d.second << ")";
}
sim dor(rge<c> d) {
*this << "[";
for (auto it = d.b; it != d.e; ++it)
*this << ", " + 2 * (it == d.b) << *it;
ris << "]";
}
#else
sim dor(const c &) { ris; }
#endif
}
;
#define imie(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "
#define shandom_ruffle random_shuffle
using ll = long long;
int main() {
int n;
cin >> n;
int a[n][3];
for (int i = 0; i < n; i++)
cin >> a[i][0] >> a[i][1] >> a[i][2];
int dp[n][3];
dp[n - 1][0] = a[n - 1][0];
dp[n - 1][1] = a[n - 1][1];
dp[n - 1][2] = a[n - 1][2];
int ans = 0;
for (int i = n - 2; i >= 0; 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]);
ans = max(ans, max(dp[i][0], max(dp[i][1], dp[i][2])));
}
cout << ans;
return 0;
} | //~ while (clock()<=69*CLOCKS_PER_SEC)
//~ #pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("O3")
//~ #pragma GCC optimize("Ofast")
//~ #pragma GCC
//target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native") ~ #pragma
//GCC optimize("unroll-loops")
#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;
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define sim template <class c
#define ris return *this
#define dor > debug &operator<<
#define eni(x) \
sim > typename enable_if<sizeof dud<c>(0) x 1, debug &>::type operator<<( \
c i) {
sim > struct rge { c b, e; };
sim > rge<c> range(c i, c j) { return rge<c>{i, j}; }
sim > auto dud(c *x) -> decltype(cerr << *x, 0);
sim > char dud(...);
struct debug {
#ifdef LOCAL
~debug() { cerr << endl; }
eni(!=) cerr << boolalpha << i;
ris;
} eni(==) ris << range(begin(i), end(i));
}
sim, class b dor(pair<b, c> d) {
ris << "(" << d.first << ", " << d.second << ")";
}
sim dor(rge<c> d) {
*this << "[";
for (auto it = d.b; it != d.e; ++it)
*this << ", " + 2 * (it == d.b) << *it;
ris << "]";
}
#else
sim dor(const c &) { ris; }
#endif
}
;
#define imie(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "
#define shandom_ruffle random_shuffle
using ll = long long;
int main() {
int n;
cin >> n;
int a[n][3];
for (int i = 0; i < n; i++)
cin >> a[i][0] >> a[i][1] >> a[i][2];
int dp[n][3];
dp[n - 1][0] = a[n - 1][0];
dp[n - 1][1] = a[n - 1][1];
dp[n - 1][2] = a[n - 1][2];
int ans = 0;
for (int i = n - 2; i >= 0; 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]);
}
ans = max(ans, max(dp[0][0], max(dp[0][1], dp[0][2])));
cout << ans;
return 0;
} | [
"identifier.replace.remove",
"literal.replace.add",
"variable_access.subscript.index.change",
"call.arguments.change"
] | 963,839 | 963,840 | u093929604 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i <= (b); i++)
#define rep(i, n) FOR(i, 0, n - 1)
typedef long long ll;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
// Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools (tips: You
// use the default template now. You can remove this line by using your custom
// template)
int main() {
long long N;
cin >> N;
ll act[N][3];
rep(i, N) {
rep(j, 3) { cin >> act[i][j]; }
}
vector<vector<ll>> dp(N, vector<ll>(3));
rep(i, N) {
rep(j, 3) {
rep(k, 3) {
if (j == k)
continue;
chmax(dp[i + 1][k], dp[i][j] + act[i][k]);
}
}
}
ll res = 0;
rep(j, 3) chmax(res, dp[N][j]);
cout << res << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i <= (b); i++)
#define rep(i, n) FOR(i, 0, n - 1)
typedef long long ll;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
// Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools (tips: You
// use the default template now. You can remove this line by using your custom
// template)
int main() {
long long N;
cin >> N;
ll act[N][3];
rep(i, N) {
rep(j, 3) { cin >> act[i][j]; }
}
vector<vector<ll>> dp(N + 10, vector<ll>(3));
rep(i, N) {
rep(j, 3) {
rep(k, 3) {
if (j == k)
continue;
chmax(dp[i + 1][k], dp[i][j] + act[i][k]);
}
}
}
ll res = 0;
rep(j, 3) chmax(res, dp[N][j]);
cout << res << endl;
}
| [
"assignment.change"
] | 963,846 | 963,847 | u270178188 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int a[n + 1], b[n + 1], c[n + 1];
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i] >> c[i];
}
long long int dp[n][4];
dp[1][1] = a[1];
dp[1][2] = b[1];
dp[1][3] = c[1];
for (int i = 2; i <= n; i++) {
dp[i][1] = max(dp[i - 1][2], dp[i - 1][2]) + a[i];
dp[i][2] = max(dp[i - 1][1], dp[i - 1][3]) + b[i];
dp[i][3] = max(dp[i - 1][2], dp[i - 1][1]) + c[i];
}
long long int ans = max(dp[n][1], max(dp[n][2], dp[n][3]));
cout << ans;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int a[n + 1], b[n + 1], c[n + 1];
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i] >> c[i];
}
long long int dp[n + 1][4];
dp[1][1] = a[1];
dp[1][2] = b[1];
dp[1][3] = c[1];
for (int i = 2; i <= n; i++) {
dp[i][1] = max(dp[i - 1][2], dp[i - 1][3]) + a[i];
dp[i][2] = max(dp[i - 1][1], dp[i - 1][3]) + b[i];
dp[i][3] = max(dp[i - 1][2], dp[i - 1][1]) + c[i];
}
long long int ans = max(dp[n][1], max(dp[n][2], dp[n][3]));
cout << ans;
} | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 963,848 | 963,849 | u040130608 | 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];
for (int i = 0; i < n; i++)
for (int j = 0; j < 3; j++)
dp[i][j] = 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++) {
for (int x = 0; x < 3; x++) {
for (int y = 0; y < 3; y++) {
if (x != y) {
dp[i][x] = max(dp[i][x], dp[i - 1][x] + a[i][y]);
}
}
}
}
cout << max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2]));
}
| #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];
for (int i = 0; i < n; i++)
for (int j = 0; j < 3; j++)
dp[i][j] = 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++) {
for (int x = 0; x < 3; x++) {
for (int y = 0; y < 3; y++) {
if (x != y) {
dp[i][y] = max(dp[i][y], dp[i - 1][x] + a[i][y]);
}
}
}
}
cout << max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2]));
}
| [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change",
"assignment.value.change",
"call.arguments.change"
] | 963,850 | 963,851 | u538921852 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define mod 1000000007
#define pll pair<long long, long long>
#define pdd pair<long double, long double>
#define mp make_pair
#define pb push_back
priority_queue<pll, vector<pll>, greater<pll>> pq;
#define ll long long
int main() {
int n;
cin >> n;
vector<ll> a(n + 1), b(n + 1), c(n + 1);
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i] >> c[i];
}
vector<vector<ll>> dp(4, vector<ll>(n + 1, 0));
for (int i = 1; i <= n; i++) {
// cout<<"sgfd";
dp[i][1] = a[i] + max(dp[i - 1][2], dp[i - 1][3]);
dp[i][2] = b[i] + max(dp[i - 1][1], dp[i - 1][3]);
dp[i][3] = c[i] + max(dp[i - 1][2], dp[i - 1][1]);
}
cout << max(dp[n][1], max(dp[n][2], dp[n][3]));
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define mod 1000000007
#define pll pair<long long, long long>
#define pdd pair<long double, long double>
#define mp make_pair
#define pb push_back
priority_queue<pll, vector<pll>, greater<pll>> pq;
#define ll long long
int main() {
int n;
cin >> n;
vector<ll> a(n + 1), b(n + 1), c(n + 1);
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i] >> c[i];
}
vector<vector<ll>> dp(n + 1, vector<ll>(4, 0));
for (int i = 1; i <= n; i++) {
// cout<<"sgfd";
dp[i][1] = a[i] + max(dp[i - 1][2], dp[i - 1][3]);
dp[i][2] = b[i] + max(dp[i - 1][1], dp[i - 1][3]);
dp[i][3] = c[i] + max(dp[i - 1][2], dp[i - 1][1]);
}
cout << max(dp[n][1], max(dp[n][2], dp[n][3]));
return 0;
}
| [
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change",
"identifier.replace.remove",
"literal.replace.add",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 963,874 | 963,875 | u029479695 | cpp |
p03162 | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
void file() {
#ifdef _DEBUG
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
typedef long long ll;
typedef pair<int, int> pi;
const ll INF64 = 1e18;
const int INF = 1e9 + 7;
#define forn(i, n) for (int i = 0; i < int(n); i++)
#define fore(i, l, r) for (int i = int(l); i < int(r); i++)
#define x first
#define y second
#define pb push_back
#define all(a) (a).begin(), (a).end()
const int N = 1e5 + 10;
int dp[N][3];
int a[N][3];
int main()
{
file();
int n, k;
cin >> n >> k;
forn(i, n) forn(j, 3) cin >> a[i][j];
dp[0][0] = a[0][0];
dp[0][1] = a[0][1];
dp[0][2] = a[0][2];
fore(i, 1, n) {
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]);
}
cout << max(max(dp[n - 1][0], dp[n - 1][1]), dp[n - 1][2]) << endl;
} | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
void file() {
#ifdef _DEBUG
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
typedef long long ll;
typedef pair<int, int> pi;
const ll INF64 = 1e18;
const int INF = 1e9 + 7;
#define forn(i, n) for (int i = 0; i < int(n); i++)
#define fore(i, l, r) for (int i = int(l); i < int(r); i++)
#define x first
#define y second
#define pb push_back
#define all(a) (a).begin(), (a).end()
const int N = 1e5 + 10;
int dp[N][3];
int a[N][3];
int main()
{
file();
int n;
cin >> n;
forn(i, n) forn(j, 3) cin >> a[i][j];
dp[0][0] = a[0][0];
dp[0][1] = a[0][1];
dp[0][2] = a[0][2];
fore(i, 1, n) {
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]);
}
cout << max(max(dp[n - 1][0], dp[n - 1][1]), dp[n - 1][2]) << endl;
} | [
"variable_declaration.remove",
"expression.operation.binary.remove"
] | 963,876 | 963,877 | u132754310 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define mod 1000000007
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
int a[n], b[n], c[n];
int dp[3][n];
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i] >> c[i];
}
dp[0][0] = a[0];
dp[1][0] = b[0];
dp[2][0] = c[0];
for (int i = 1; i < n; i++) {
dp[0][i] = a[i] + max(dp[1][i - 1], dp[2][i - 1]);
dp[1][i] = b[i] + max(dp[0][i - 1], dp[2][i - 1]);
dp[2][i] = c[i] + max(dp[0][i - 1], dp[1][i - 1]);
}
cout << max(dp[0][n - 1], max(dp[1][n - 1], dp[2][n - 2])) << "\n";
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define mod 1000000007
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
int a[n], b[n], c[n];
int dp[3][n];
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i] >> c[i];
}
dp[0][0] = a[0];
dp[1][0] = b[0];
dp[2][0] = c[0];
for (int i = 1; i < n; i++) {
dp[0][i] = a[i] + max(dp[1][i - 1], dp[2][i - 1]);
dp[1][i] = b[i] + max(dp[0][i - 1], dp[2][i - 1]);
dp[2][i] = c[i] + max(dp[0][i - 1], dp[1][i - 1]);
}
cout << max(dp[0][n - 1], max(dp[1][n - 1], dp[2][n - 1])) << "\n";
} | [
"literal.number.change",
"variable_access.subscript.index.change",
"io.output.change"
] | 963,880 | 963,881 | u222329105 | cpp |
p03162 | #include <algorithm>
#include <cctype>
#include <chrono>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <locale>
#include <map>
#include <math.h>
#include <memory>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <vector>
/*,---. ,--. ,--.
' .-' | ,---. ,--.,--. ,--. ,--. `--'
`. `-. | .-. | | || | \ `' / ,--.
.-' | | | | | ' '' ' \ / | |
`-----' `--' `--' `----' `--' `--'*/
using namespace std;
int n;
long long f(int pos, vector<long long> vals) {
if (pos == -1) {
return 0;
}
int zero = 0;
int one = 0;
vector<long long> zeroVal;
vector<long long> oneVal;
for (int i = 0; i < vals.size(); i++) {
if (((vals[i]) & (1 << pos)) != 0) {
oneVal.push_back(vals[i]);
} else {
zeroVal.push_back(vals[i]);
}
}
if (zeroVal.size() == 0 || oneVal.size() == 0) {
return f(pos - 1, vals);
} else {
return min(f(pos - 1, zeroVal), f(pos - 1, oneVal)) + (1 << pos);
}
}
int dp[200047][3];
int value[200047][3];
int main() {
int k;
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
cin >> value[i][j];
}
}
dp[0][0] = value[0][0];
dp[0][1] = value[0][1];
dp[0][2] = value[0][2];
for (int i = 1; i < n; i++) {
dp[i][0] = max(dp[i - 1][1] + value[i][1], dp[i - 1][2] + value[i][2]);
dp[i][1] = max(dp[i - 1][2] + value[i][2], dp[i - 1][0] + value[i][0]);
dp[i][2] = max(dp[i - 1][1] + value[i][1], dp[i - 1][0] + value[i][0]);
}
cout << max(dp[n - 1][2], max(dp[n - 1][0], dp[n - 1][1]));
} | #include <algorithm>
#include <cctype>
#include <chrono>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <locale>
#include <map>
#include <math.h>
#include <memory>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <vector>
/*,---. ,--. ,--.
' .-' | ,---. ,--.,--. ,--. ,--. `--'
`. `-. | .-. | | || | \ `' / ,--.
.-' | | | | | ' '' ' \ / | |
`-----' `--' `--' `----' `--' `--'*/
using namespace std;
int n;
long long f(int pos, vector<long long> vals) {
if (pos == -1) {
return 0;
}
int zero = 0;
int one = 0;
vector<long long> zeroVal;
vector<long long> oneVal;
for (int i = 0; i < vals.size(); i++) {
if (((vals[i]) & (1 << pos)) != 0) {
oneVal.push_back(vals[i]);
} else {
zeroVal.push_back(vals[i]);
}
}
if (zeroVal.size() == 0 || oneVal.size() == 0) {
return f(pos - 1, vals);
} else {
return min(f(pos - 1, zeroVal), f(pos - 1, oneVal)) + (1 << pos);
}
}
int dp[200047][3];
int value[200047][3];
int main() {
int k;
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
cin >> value[i][j];
}
}
dp[0][0] = value[0][0];
dp[0][1] = value[0][1];
dp[0][2] = value[0][2];
for (int i = 1; i < n; i++) {
dp[i][0] = max(dp[i - 1][1] + value[i][0], dp[i - 1][2] + value[i][0]);
dp[i][1] = max(dp[i - 1][2] + value[i][1], dp[i - 1][0] + value[i][1]);
dp[i][2] = max(dp[i - 1][1] + value[i][2], dp[i - 1][0] + value[i][2]);
}
cout << max(dp[n - 1][2], max(dp[n - 1][0], dp[n - 1][1]));
} | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 963,888 | 963,889 | u533400718 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
void solve() {
int N;
cin >> N;
vector<int> dp(3);
for (int day = 0; day < N; day++) {
vector<int> new_dp(3, 0);
vector<int> c(3);
for (int i = 0; i < 3; i++) {
cin >> i;
}
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;
}
int k;
k = max({dp[0], dp[1], dp[2]});
cout << k << endl;
}
int main() { solve(); }
| #include <bits/stdc++.h>
using namespace std;
void solve() {
int N;
cin >> N;
vector<int> dp(3);
for (int day = 0; day < N; day++) {
vector<int> new_dp(3, 0);
vector<int> c(3);
for (int i = 0; i < 3; i++) {
cin >> c[i];
}
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;
}
int k;
k = max({dp[0], dp[1], dp[2]});
cout << k << endl;
}
int main() { solve(); }
| [] | 963,890 | 963,891 | u440619190 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define llt long long int
#define pb push_back
void fun(int n, llt dp[][3], int a[], int b[], int c[]) {
if (n == 0) {
dp[n][0] = a[0];
dp[n][1] = b[0];
dp[n][2] = c[0];
} else {
fun(n - 1, dp, a, b, c);
dp[n][0] = max(dp[n - 1][1] + a[n], dp[n - 1][2] + a[n]);
dp[n][1] = max(dp[n - 1][0] + b[n], dp[n - 1][2] + b[n]);
dp[n][2] = max(dp[n - 1][1] + c[n], dp[n - 1][0] + c[n]);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
int a[n], b[n], c[n];
llt dp[n][3];
for (int i = 0; i < n; i++)
cin >> a[i] >> b[i] >> c[i];
fun(n - 1, dp, a, b, c);
cout << max(dp[n - 1][0], max(dp[n - 1][0], dp[n - 1][0]));
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define llt long long int
#define pb push_back
void fun(int n, llt dp[][3], int a[], int b[], int c[]) {
if (n == 0) {
dp[n][0] = a[0];
dp[n][1] = b[0];
dp[n][2] = c[0];
} else {
fun(n - 1, dp, a, b, c);
dp[n][0] = max(dp[n - 1][1] + a[n], dp[n - 1][2] + a[n]);
dp[n][1] = max(dp[n - 1][0] + b[n], dp[n - 1][2] + b[n]);
dp[n][2] = max(dp[n - 1][1] + c[n], dp[n - 1][0] + c[n]);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
int a[n], b[n], c[n];
llt dp[n][3];
for (int i = 0; i < n; i++)
cin >> a[i] >> b[i] >> c[i];
fun(n - 1, dp, a, b, c);
cout << max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2]));
return 0;
}
| [
"literal.number.change",
"variable_access.subscript.index.change",
"io.output.change"
] | 963,894 | 963,895 | u356063349 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define llt long long int
#define pb push_back
void fun(int n, int dp[][3], int a[], int b[], int c[]) {
if (n == 0) {
dp[n][0] = a[0];
dp[n][1] = b[0];
dp[n][2] = c[0];
} else {
fun(n - 1, dp, a, b, c);
dp[n][0] = max(dp[n - 1][1] + a[n], dp[n - 1][2] + a[n]);
dp[n][1] = max(dp[n - 1][0] + b[n], dp[n - 1][2] + b[n]);
dp[n][2] = max(dp[n - 1][1] + c[n], dp[n - 1][0] + c[n]);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
int a[n], b[n], c[n];
int dp[n][3];
for (int i = 0; i < n; i++)
cin >> a[i] >> b[i] >> c[i];
fun(n - 1, dp, a, b, c);
cout << max(dp[n - 1][0], max(dp[n - 1][0], dp[n - 1][0]));
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define llt long long int
#define pb push_back
void fun(int n, llt dp[][3], int a[], int b[], int c[]) {
if (n == 0) {
dp[n][0] = a[0];
dp[n][1] = b[0];
dp[n][2] = c[0];
} else {
fun(n - 1, dp, a, b, c);
dp[n][0] = max(dp[n - 1][1] + a[n], dp[n - 1][2] + a[n]);
dp[n][1] = max(dp[n - 1][0] + b[n], dp[n - 1][2] + b[n]);
dp[n][2] = max(dp[n - 1][1] + c[n], dp[n - 1][0] + c[n]);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
int a[n], b[n], c[n];
llt dp[n][3];
for (int i = 0; i < n; i++)
cin >> a[i] >> b[i] >> c[i];
fun(n - 1, dp, a, b, c);
cout << max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2]));
return 0;
}
| [
"variable_declaration.type.change",
"literal.number.change",
"variable_access.subscript.index.change",
"io.output.change"
] | 963,896 | 963,895 | u356063349 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define llt long long int
#define pb push_back
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
int a, b, c;
llt dp[3][2];
cin >> a >> b >> c;
n--;
dp[0][0] = a;
dp[1][0] = b;
dp[2][0] = c;
while (n--) {
cin >> a >> b >> c;
dp[0][1] = max(dp[1][0] + b, dp[2][0] + c);
dp[1][1] = max(dp[0][0] + a, dp[2][0] + c);
dp[2][1] = max(dp[1][0] + b, dp[0][0] + a);
dp[0][0] = dp[0][1];
dp[1][0] = dp[1][1];
dp[2][0] = dp[2][1];
}
cout << max(dp[0][0], max(dp[1][0], dp[2][0]));
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define llt long long int
#define pb push_back
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
int a, b, c;
llt dp[3][2];
cin >> a >> b >> c;
n--;
dp[0][0] = a;
dp[1][0] = b;
dp[2][0] = c;
while (n--) {
cin >> a >> b >> c;
dp[0][1] = max(dp[1][0] + a, dp[2][0] + a);
dp[1][1] = max(dp[0][0] + b, dp[2][0] + b);
dp[2][1] = max(dp[1][0] + c, dp[0][0] + c);
dp[0][0] = dp[0][1];
dp[1][0] = dp[1][1];
dp[2][0] = dp[2][1];
}
cout << max(dp[0][0], max(dp[1][0], dp[2][0]));
return 0;
}
| [
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 963,897 | 963,898 | u356063349 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
int a, b, c, dp[3], d, e, f;
cin >> a >> b >> c;
dp[0] = a;
dp[1] = b;
dp[2] = c;
for (int i = 1; i < n; i++) {
cin >> a >> b >> c;
d = (dp[1] > dp[2]) ? dp[1] + a : dp[2] + a;
e = (dp[0] > dp[2]) ? dp[0] + b : dp[2] + b;
f = (dp[1] > dp[0]) ? dp[1] + c : dp[2] + c;
dp[0] = d;
dp[1] = e;
dp[2] = f;
}
cout << max(dp[0], max(dp[1], dp[2]));
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
int a, b, c, dp[3], d, e, f;
cin >> a >> b >> c;
dp[0] = a;
dp[1] = b;
dp[2] = c;
for (int i = 1; i < n; i++) {
cin >> a >> b >> c;
d = (dp[1] > dp[2]) ? dp[1] + a : dp[2] + a;
e = (dp[0] > dp[2]) ? dp[0] + b : dp[2] + b;
f = (dp[1] > dp[0]) ? dp[1] + c : dp[0] + c;
dp[0] = d;
dp[1] = e;
dp[2] = f; // cout<<dp[0]<<" "<<dp[1]<<" "<<dp[2]<<endl;
}
cout << max(dp[0], max(dp[1], dp[2]));
return 0;
} | [
"literal.number.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 963,899 | 963,900 | u356063349 | cpp |
p03162 | #include <iostream>
using namespace std;
int main() {
long long int i, n;
cin >> n;
long long int a[n + 10], b[n + 10], c[n + 10], A[n + 10], B[n + 10],
C[n + 10];
for (i = 1; i <= n; i++)
cin >> a[i] >> b[i] >> c[i];
for (i = 1; i <= n; i++) {
A[i] = 0;
B[i] = 0;
C[i] = 0;
}
A[1] = a[1];
B[1] = b[1];
C[1] = c[1];
for (i = 1; i <= n; i++) {
A[i] = max(B[i - 1], C[i - 1]) + a[i];
B[i] = max(A[i - 1], C[i - 1]) + b[i];
C[i] = max(B[i - 1], A[i - 1]) + c[i];
}
cout << max(max(A[n], B[n]), C[n]);
}
| #include <iostream>
using namespace std;
int main() {
long long int i, n, s = 0;
cin >> n;
long long int a[n + 10], b[n + 10], c[n + 10], A[n + 10], B[n + 10],
C[n + 10];
for (i = 1; i <= n; i++)
cin >> a[i] >> b[i] >> c[i];
for (i = 1; i <= n; i++) {
A[i] = 0;
B[i] = 0;
C[i] = 0;
}
A[1] = a[1];
B[1] = b[1];
C[1] = c[1];
for (i = 2; i <= n; i++) {
A[i] = max(B[i - 1], C[i - 1]) + a[i];
B[i] = max(A[i - 1], C[i - 1]) + b[i];
C[i] = max(B[i - 1], A[i - 1]) + c[i];
}
cout << max(max(A[n], B[n]), C[n]);
}
| [
"variable_declaration.add",
"literal.number.change",
"assignment.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 963,909 | 963,910 | u985186777 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<vector<int>> a(n, vector<int>(3, 0));
vector<vector<int>> dp(n, vector<int>(3, 0));
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++) {
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] + a[i][k]);
}
}
}
}
cout << max({dp[n - 1][0], dp[n - 1][1], dp[n - 1][2]}) << '\n';
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<vector<int>> a(n, vector<int>(3, 0));
vector<vector<int>> dp(n, vector<int>(3, 0));
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++) {
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], dp[n - 1][1], dp[n - 1][2]}) << '\n';
return 0;
}
| [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 963,915 | 963,916 | u824642100 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<vector<int>> a(n, vector<int>(3, 0));
vector<vector<int>> dp(n, vector<int>(3, 0));
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++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
if (j != k) {
dp[i][j] = max(dp[i][j], dp[i - 1][j] + a[i][k]);
}
}
}
}
cout << max({dp[n - 1][0], dp[n - 1][1], dp[n - 1][2]}) << '\n';
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<vector<int>> a(n, vector<int>(3, 0));
vector<vector<int>> dp(n, vector<int>(3, 0));
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++) {
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], dp[n - 1][1], dp[n - 1][2]}) << '\n';
return 0;
}
| [
"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"
] | 963,917 | 963,916 | u824642100 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) \
; \
for (long long i = 0; i < (n); i++)
typedef long long ll;
typedef vector<long long> vl;
const ll INF = 100000000009;
ll dp[100005][3];
ll abc[100005][3];
template <class T> inline bool chmax(T &x, T y) {
if (x < y) {
x = y;
return true;
} else
return false;
}
int main() {
ll n;
cin >> n;
rep(i, n) {
rep(j, 3) { cin >> abc[i][j]; }
}
rep(i, n) {
rep(now, 3) {
rep(nex, 3) {
if (now == nex)
continue;
chmax(dp[i + 1][nex], dp[i][now] + abc[i][nex]);
}
}
}
ll ans = 0;
rep(i, 3) ans = max(ans, dp[n - 1][i]);
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) \
; \
for (long long i = 0; i < (n); i++)
typedef long long ll;
typedef vector<long long> vl;
const ll INF = 100000000009;
ll dp[100005][3];
ll abc[100005][3];
template <class T> inline bool chmax(T &x, T y) {
if (x < y) {
x = y;
return true;
} else
return false;
}
int main() {
ll n;
cin >> n;
rep(i, n) {
rep(j, 3) { cin >> abc[i][j]; }
}
rep(i, n) {
rep(now, 3) {
rep(nex, 3) {
if (now == nex)
continue;
chmax(dp[i + 1][nex], dp[i][now] + abc[i][nex]);
}
}
}
ll ans = 0;
rep(i, 3) ans = max(ans, dp[n][i]);
cout << ans << endl;
} | [
"expression.operation.binary.remove"
] | 963,918 | 963,919 | u583628727 | cpp |
p03162 | #include <iostream>
int abs(int a) { return (a > 0) ? a : -a; }
int main() {
int n;
std::cin >> n;
int a[n], b[n], c[n];
for (int i = 0; i < n; i++)
std::cin >> a[i] >> b[i] >> c[i];
int dpa[n], dpb[n], dpc[n];
dpa[0] = a[0];
dpb[0] = b[0];
dpc[0] = c[0];
for (int i = 1; i < n; i++) {
dpa[i] = a[i] + std::max(dpb[i - 1], dpc[i - 1]);
dpb[i] = b[i] + std::max(dpa[i - 1], dpc[i - 1]);
dpc[i] = c[i] + std::max(dpa[i - 1], dpb[i - 1]);
}
std::cout << std::max(a[n - 1], std::max(b[n - 1], c[n - 1])) << std::endl;
return 0;
} | #include <iostream>
int abs(int a) { return (a > 0) ? a : -a; }
int main() {
int n;
std::cin >> n;
int a[n], b[n], c[n];
for (int i = 0; i < n; i++)
std::cin >> a[i] >> b[i] >> c[i];
int dpa[n], dpb[n], dpc[n];
dpa[0] = a[0];
dpb[0] = b[0];
dpc[0] = c[0];
for (int i = 1; i < n; i++) {
dpa[i] = a[i] + std::max(dpb[i - 1], dpc[i - 1]);
dpb[i] = b[i] + std::max(dpa[i - 1], dpc[i - 1]);
dpc[i] = c[i] + std::max(dpa[i - 1], dpb[i - 1]);
}
std::cout << std::max(dpa[n - 1], std::max(dpb[n - 1], dpc[n - 1]))
<< std::endl;
return 0;
} | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 963,920 | 963,921 | u387880194 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<vector<long long>> dp(n, vector<long long>(3, -1));
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];
for (int i = 1; i < n; i++) {
h[i][0] = h[i][0] + max(h[i - 11][1], h[i - 1][2]);
h[i][1] = h[i][1] + max(h[i - 1][0], h[i - 1][2]);
h[i][2] = h[i][2] + max(h[i - 1][1], h[i - 1][0]);
}
int m = max({h[n - 1][0], h[n - 1][1], h[n - 1][2]});
cout << m;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<vector<long long>> dp(n, vector<long long>(3, -1));
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];
for (int i = 1; i < n; i++) {
h[i][0] = h[i][0] + max(h[i - 1][1], h[i - 1][2]);
h[i][1] = h[i][1] + max(h[i - 1][0], h[i - 1][2]);
h[i][2] = h[i][2] + max(h[i - 1][1], h[i - 1][0]);
}
int m = max({h[n - 1][0], h[n - 1][1], h[n - 1][2]});
cout << m;
}
| [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 963,924 | 963,925 | u456910634 | cpp |
p03162 | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <map>
#include <math.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int N;
cin >> N;
vector<int> a(N);
vector<int> b(N);
vector<int> c(N);
vector<vector<int>> v(N, vector<int>(3));
for (int i = 0; i < N; i++) {
cin >> a[i] >> b[i] >> c[i];
}
v[0][0] = a[0];
v[0][1] = b[0];
v[0][1] = c[0];
for (int i = 1; i < N; i++) {
v[i][0] = a[i] + max(v[i - 1][1], v[i - 1][2]);
v[i][1] = b[i] + max(v[i - 1][0], v[i - 1][2]);
v[i][2] = c[i] + max(v[i - 1][1], v[i - 1][0]);
}
cout << max(v[N - 1][0], max(v[N - 1][2], v[N - 1][1])) << '\n';
} | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <map>
#include <math.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int N;
cin >> N;
vector<int> a(N);
vector<int> b(N);
vector<int> c(N);
vector<vector<int>> v(N, vector<int>(3));
for (int i = 0; i < N; i++) {
cin >> a[i] >> b[i] >> c[i];
}
v[0][0] = a[0];
v[0][1] = b[0];
v[0][2] = c[0];
for (int i = 1; i < N; i++) {
v[i][0] = a[i] + max(v[i - 1][1], v[i - 1][2]);
v[i][1] = b[i] + max(v[i - 1][0], v[i - 1][2]);
v[i][2] = c[i] + max(v[i - 1][1], v[i - 1][0]);
}
cout << max(v[N - 1][0], max(v[N - 1][2], v[N - 1][1])) << '\n';
} | [
"literal.number.change",
"assignment.variable.change",
"variable_access.subscript.index.change"
] | 963,926 | 963,927 | u340010271 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define fast \
{ \
ios ::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0); \
}
#define pb push_back
#define ll long long
#define vi vector<int>
#define vl vector<long>
#define vll vector<long long>
#define infi INT_MAX
#define infl LONG_MAX
#define f(i, a, b) for (ll i = a; i < b; i++)
#define fi(i, a, b) for (ll i = (b - 1); i >= a; i--)
#define F first
#define S second
#define G(a, b) get<a>(b)
#define MP make_pair
#define MT make_tuple
void func() {
ll n;
cin >> n;
ll a[n + 1], b[n + 1], c[n + 1], dp1[n + 1], dp2[n + 1], dp3[n + 1];
f(i, 1, n + 1) cin >> a[i] >> b[i] >> c[i];
dp1[0] = dp2[0] = dp3[0];
f(i, 1, n + 1) {
dp1[i] = a[i] + max(dp2[i - 1], dp3[i - 1]);
dp2[i] = b[i] + max(dp1[i - 1], dp3[i - 1]);
dp3[i] = c[i] + max(dp1[i - 1], dp2[i - 1]);
}
ll ans = (ll)max((ll)max(dp1[n], dp2[n]), dp3[n]);
cout << ans << endl;
}
int main() {
fast
// freopen("input.txt","r",stdin); freopen("output.txt","w",stdout);
ll q = 1;
// cin>>q;
while (q) {
func();
q--;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define fast \
{ \
ios ::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0); \
}
#define pb push_back
#define ll long long
#define vi vector<int>
#define vl vector<long>
#define vll vector<long long>
#define infi INT_MAX
#define infl LONG_MAX
#define f(i, a, b) for (ll i = a; i < b; i++)
#define fi(i, a, b) for (ll i = (b - 1); i >= a; i--)
#define F first
#define S second
#define G(a, b) get<a>(b)
#define MP make_pair
#define MT make_tuple
void func() {
ll n;
cin >> n;
ll a[n + 1], b[n + 1], c[n + 1], dp1[n + 1], dp2[n + 1], dp3[n + 1];
f(i, 1, n + 1) cin >> a[i] >> b[i] >> c[i];
dp1[0] = dp2[0] = dp3[0] = 0;
// f(i,1,n+1) cout<<a[i]<<" "<<b[i]<<" "<<c[i]<<endl;
f(i, 1, n + 1) {
dp1[i] = a[i] + max(dp2[i - 1], dp3[i - 1]);
dp2[i] = b[i] + max(dp1[i - 1], dp3[i - 1]);
dp3[i] = c[i] + max(dp1[i - 1], dp2[i - 1]);
}
// f(i,1,n) cout<<dp1[i]<<" "<<dp2[i]<<" "<<dp3[i]<<endl;
ll ans = (ll)max((ll)max(dp1[n], dp2[n]), dp3[n]);
cout << ans << endl;
}
int main() {
fast
// freopen("input.txt","r",stdin); freopen("output.txt","w",stdout);
ll q = 1;
// cin>>q;
while (q) {
func();
q--;
}
return 0;
} | [
"assignment.change"
] | 963,931 | 963,932 | u377859957 | cpp |
p03162 | #include <bits/stdc++.h>
#define ll long long
#define inf 0
using namespace std;
int main() {
// ll t; cin>> t; while(t--){
ll n, m = 3;
cin >> n;
ll a[n][m], dp[n][m];
for (ll i = 0; i < n; i++) {
for (ll j = 0; j < m; j++) {
cin >> a[i][j];
dp[i][j] = inf;
}
}
for (ll j = 0; j < m; j++) {
dp[0][j] = a[0][j];
}
for (ll i = 1; i < n; i++) {
for (ll j = 0; j < m; j++) {
for (ll k = 0; k < m; k++) {
if (j != k)
dp[i][k] = min(dp[i][k], dp[i - 1][j] + a[i][k]);
}
}
}
ll ans = inf;
for (ll j = 0; j < m; j++) {
ans = min(ans, dp[n - 1][j]);
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
#define ll long long
#define inf 0
using namespace std;
int main() {
// ll t; cin>> t; while(t--){
ll n, m = 3;
cin >> n;
ll a[n][m], dp[n][m];
for (ll i = 0; i < n; i++) {
for (ll j = 0; j < m; j++) {
cin >> a[i][j];
dp[i][j] = inf;
}
}
for (ll j = 0; j < m; j++) {
dp[0][j] = a[0][j];
}
for (ll i = 1; i < n; i++) {
for (ll j = 0; j < m; j++) {
for (ll k = 0; k < m; k++) {
if (j != k)
dp[i][k] = max(dp[i][k], dp[i - 1][j] + a[i][k]);
}
}
}
ll ans = inf;
for (ll j = 0; j < m; j++) {
ans = max(ans, dp[n - 1][j]);
}
cout << ans << endl;
}
| [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 963,940 | 963,941 | u448570453 | cpp |
p03162 | #include <bits/stdc++.h>
#define ll long long
#define inf 1000000005
using namespace std;
int main() {
// ll t; cin>> t; while(t--){
ll n, m = 3;
cin >> n;
ll a[n][m], dp[n][m];
for (ll i = 0; i < n; i++) {
for (ll j = 0; j < m; j++) {
cin >> a[i][j];
dp[i][j] = inf;
}
}
for (ll j = 0; j < m; j++) {
dp[0][j] = a[0][j];
}
for (ll i = 1; i < n; i++) {
for (ll j = 0; j < m; j++) {
for (ll k = 0; k < m; k++) {
if (j != k)
dp[i][k] = max(dp[i][k], dp[i - 1][j] + a[i][k]);
}
}
}
ll ans = 0;
for (ll j = 0; j < m; j++) {
ans = max(ans, dp[n - 1][j]);
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
#define ll long long
#define inf 0
using namespace std;
int main() {
// ll t; cin>> t; while(t--){
ll n, m = 3;
cin >> n;
ll a[n][m], dp[n][m];
for (ll i = 0; i < n; i++) {
for (ll j = 0; j < m; j++) {
cin >> a[i][j];
dp[i][j] = inf;
}
}
for (ll j = 0; j < m; j++) {
dp[0][j] = a[0][j];
}
for (ll i = 1; i < n; i++) {
for (ll j = 0; j < m; j++) {
for (ll k = 0; k < m; k++) {
if (j != k)
dp[i][k] = max(dp[i][k], dp[i - 1][j] + a[i][k]);
}
}
}
ll ans = inf;
for (ll j = 0; j < m; j++) {
ans = max(ans, dp[n - 1][j]);
}
cout << ans << endl;
}
| [
"preprocessor.define.value.change",
"literal.integer.change",
"variable_declaration.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 963,942 | 963,941 | u448570453 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define fs first
#define sc second
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define ALL(A) A.begin(), A.end()
#define RALL(A) A.rbegin(), A.rend()
typedef long long ll;
typedef pair<ll, ll> P;
const ll mod = 1000000007;
const ll LINF = 1LL << 60;
const int INF = 1 << 30;
int main() {
ll n;
cin >> n;
vector<ll> a(n);
vector<ll> b(n);
vector<ll> c(n);
for (ll i = 0; i < n; i++) {
cin >> a[i] >> b[i] >> c[i];
}
vector<vector<ll>> dp(n, vector<ll>(3, -1));
dp[0][0] = a[0];
dp[0][1] = b[0];
dp[0][1] = c[0];
for (ll 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][0] + b[i], dp[i - 1][2] + 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;
} | #include <bits/stdc++.h>
using namespace std;
#define fs first
#define sc second
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define ALL(A) A.begin(), A.end()
#define RALL(A) A.rbegin(), A.rend()
typedef long long ll;
typedef pair<ll, ll> P;
const ll mod = 1000000007;
const ll LINF = 1LL << 60;
const int INF = 1 << 30;
int main() {
ll n;
cin >> n;
vector<ll> a(n);
vector<ll> b(n);
vector<ll> c(n);
for (ll i = 0; i < n; i++) {
cin >> a[i] >> b[i] >> c[i];
}
vector<vector<ll>> dp(n, vector<ll>(3, -1));
dp[0][0] = a[0];
dp[0][1] = b[0];
dp[0][2] = c[0];
for (ll 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][0] + b[i], dp[i - 1][2] + 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;
} | [
"literal.number.change",
"assignment.variable.change",
"variable_access.subscript.index.change"
] | 963,943 | 963,944 | u471212175 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vec;
typedef unsigned long long ull;
typedef unsigned int ui;
typedef pair<int, int> par;
typedef vector<par> vpar;
#define forn(i, n) for (ll i = 0; i < n; i++)
#define wez(n) \
ll(n); \
cin >> (n);
#define setmax(a, b) (a) = max((a), (b))
#define setmin(a, b) (a) = min((a), (b))
#define pb push_back
#define mp make_pair
#define outa(a, e) forn(i, e) cout << a[i] << (i == e - 1 ? '\n' : ' ')
#define oute(n) cout << n << "\n"
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
/* #ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif*/
wez(n);
vector<ll> dp(3, 0);
forn(i, n) {
vector<ll> new_dp(3, 0);
vector<int> cost(3);
forn(j, 3) cin >> cost[j];
forn(j, 3) {
forn(k, 3) {
if (j != k) {
new_dp[j] = max(new_dp[j], dp[i] + cost[j]);
}
}
}
dp = new_dp;
}
cout << max(dp[0], max(dp[1], dp[2]));
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vec;
typedef unsigned long long ull;
typedef unsigned int ui;
typedef pair<int, int> par;
typedef vector<par> vpar;
#define forn(i, n) for (ll i = 0; i < n; i++)
#define wez(n) \
ll(n); \
cin >> (n);
#define setmax(a, b) (a) = max((a), (b))
#define setmin(a, b) (a) = min((a), (b))
#define pb push_back
#define mp make_pair
#define outa(a, e) forn(i, e) cout << a[i] << (i == e - 1 ? '\n' : ' ')
#define oute(n) cout << n << "\n"
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
/* #ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif*/
wez(n);
vector<ll> dp(3, 0);
forn(i, n) {
vector<ll> new_dp(3, 0);
vector<int> cost(3);
forn(j, 3) cin >> cost[j];
forn(j, 3) {
forn(k, 3) {
if (j != k) {
new_dp[k] = max(new_dp[k], dp[j] + cost[k]);
}
}
}
dp = new_dp;
}
cout << max(dp[0], max(dp[1], dp[2]));
return 0;
}
| [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 963,947 | 963,948 | u797339743 | cpp |
p03162 | #include <bits/stdc++.h>
#define IO \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
using namespace std;
const int N = 1e5 + 5;
int a[N], b[N], c[N], n;
int dp[N][4];
int k;
int INF = 0x3f3f3f3f;
int solve(int i, int last) {
if (i == n)
return 0;
int &ret = dp[i][last];
if (~ret)
return ret;
if (!last)
ret = max(solve(i + 1, 1) + a[i],
max(solve(i + 1, 2) + b[i], solve(i + 1, 2) + c[i]));
else if (last == 1) {
ret = max(solve(i + 1, 2) + b[i], solve(i + 1, 3) + c[i]);
} else if (last == 2) {
ret = max(solve(i + 1, 1) + a[i], solve(i + 1, 3) + c[i]);
} else if (last == 3) {
ret = max(solve(i + 1, 1) + a[i], solve(i + 1, 2) + b[i]);
}
return ret;
}
int main() {
IO;
memset(dp, -1, sizeof(dp));
cin >> n;
for (int i = 0; i < n; ++i)
cin >> a[i] >> b[i] >> c[i];
cout << solve(0, 0);
}
| #include <bits/stdc++.h>
#define IO \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
using namespace std;
const int N = 1e5 + 5;
int a[N], b[N], c[N], n;
int dp[N][4];
int k;
int INF = 0x3f3f3f3f;
int solve(int i, int last) {
if (i == n)
return 0;
int &ret = dp[i][last];
if (~ret)
return ret;
if (!last)
ret = max(solve(i + 1, 1) + a[i],
max(solve(i + 1, 2) + b[i], solve(i + 1, 3) + c[i]));
else if (last == 1) {
ret = max(solve(i + 1, 2) + b[i], solve(i + 1, 3) + c[i]);
} else if (last == 2) {
ret = max(solve(i + 1, 1) + a[i], solve(i + 1, 3) + c[i]);
} else if (last == 3) {
ret = max(solve(i + 1, 1) + a[i], solve(i + 1, 2) + b[i]);
}
return ret;
}
int main() {
IO;
memset(dp, -1, sizeof(dp));
cin >> n;
for (int i = 0; i < n; ++i)
cin >> a[i] >> b[i] >> c[i];
cout << solve(0, 0);
}
| [
"literal.number.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 963,951 | 963,952 | u208483272 | cpp |
p03162 | #include <bits/stdc++.h>
#define rep(i, a, b) for (int i = a; i < b; i++)
using namespace std;
typedef long long ll;
const int inf = INT_MAX / 2;
const ll infl = 1LL << 60;
const ll mod = 1e9 + 7;
template <typename T> ostream &operator<<(ostream &os, vector<T> v) {
for (auto &i : v)
os << i << " ";
return os;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &i : v)
is >> i;
return is;
}
template <typename K, typename V>
ostream &operator<<(ostream &os, unordered_map<K, V> m) {
for (auto &i : m)
os << i.first << ":" << i.second << endl;
return os;
}
template <typename T> inline bool chmin(T &x, T y) {
if (x > y) {
x = y;
return true;
}
return false;
}
template <typename T> inline bool chmax(T &x, T y) {
if (x < y) {
x = y;
return true;
}
return false;
}
int N, K;
int A[100010][3];
int dp[100010][3];
int main() {
cin >> N;
rep(i, 0, N) rep(j, N, 3) cin >> A[i][j];
rep(i, 0, 3) dp[0][i] = A[0][i];
rep(i, 1, N) rep(lst, 0, 3) {
rep(nxt, 0, 3) if (lst != nxt)
chmax(dp[i][nxt], dp[i - 1][lst] + A[i][nxt]);
}
int ans = 0;
rep(i, 0, 3) chmax(ans, dp[N - 1][i]);
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, a, b) for (int i = a; i < b; i++)
using namespace std;
typedef long long ll;
const int inf = INT_MAX / 2;
const ll infl = 1LL << 60;
const ll mod = 1e9 + 7;
template <typename T> ostream &operator<<(ostream &os, vector<T> v) {
for (auto &i : v)
os << i << " ";
return os;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &i : v)
is >> i;
return is;
}
template <typename K, typename V>
ostream &operator<<(ostream &os, unordered_map<K, V> m) {
for (auto &i : m)
os << i.first << ":" << i.second << endl;
return os;
}
template <typename T> inline bool chmin(T &x, T y) {
if (x > y) {
x = y;
return true;
}
return false;
}
template <typename T> inline bool chmax(T &x, T y) {
if (x < y) {
x = y;
return true;
}
return false;
}
int N;
int A[100010][3];
int dp[100010][3];
int main() {
cin >> N;
rep(i, 0, N) rep(j, 0, 3) cin >> A[i][j];
rep(i, 0, 3) dp[0][i] = A[0][i];
rep(i, 1, N) rep(lst, 0, 3) {
rep(nxt, 0, 3) if (lst != nxt)
chmax(dp[i][nxt], dp[i - 1][lst] + A[i][nxt]);
}
int ans = 0;
rep(i, 0, 3) chmax(ans, dp[N - 1][i]);
cout << ans << endl;
return 0;
}
| [
"variable_declaration.remove",
"identifier.replace.remove",
"literal.replace.add",
"call.arguments.change"
] | 963,957 | 963,958 | u171804186 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> s(n + 1, 0), b(n + 1, 0), h(n + 1, 0);
vector<vector<int>> p(n + 1, vector<int>(3, 0));
for (int i = 0; i < n; i++) {
cin >> s[i] >> b[i] >> h[i];
}
for (int i = 1; i <= n; i++) {
p[i][0] = s[i] + max(p[i - 1][1], p[i - 1][2]);
p[i][1] = b[i] + max(p[i - 1][0], p[i - 1][2]);
p[i][2] = h[i] + max(p[i - 1][0], p[i - 1][1]);
}
int points = max(p[n][0], p[n][1]);
cout << max(points, p[n][2]);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> s(n + 1, 0), b(n + 1, 0), h(n + 1, 0);
vector<vector<int>> p(n + 1, vector<int>(3, 0));
for (int i = 1; i <= n; i++) {
cin >> s[i] >> b[i] >> h[i];
}
for (int i = 1; i <= n; i++) {
p[i][0] = s[i] + max(p[i - 1][1], p[i - 1][2]);
p[i][1] = b[i] + max(p[i - 1][0], p[i - 1][2]);
p[i][2] = h[i] + max(p[i - 1][0], p[i - 1][1]);
}
int points = max(p[n][0], p[n][1]);
cout << max(points, p[n][2]);
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 963,963 | 963,964 | u000931732 | cpp |
p03162 | #include <bits/stdc++.h>
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define sz(x) ll(x.size())
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
ll n, ans = 0;
cin >> n;
vector<vector<ll>> dp(n + 5, vector<ll>(3));
vector<ll> a(n);
vector<ll> b(n);
vector<ll> c(n);
rep(i, n) cin >> a.at(i) >> b.at(i) >> c.at(i);
dp[0][0] = 0;
dp[0][1] = 0;
dp[0][2] = 0;
rep(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]);
}
rep(i, 3) ans = max(ans, dp[n - 1][i]);
cout << ans << endl;
}
| #include <bits/stdc++.h>
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define sz(x) ll(x.size())
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
ll n, ans = 0;
cin >> n;
vector<vector<ll>> dp(n + 5, vector<ll>(3));
vector<ll> a(n);
vector<ll> b(n);
vector<ll> c(n);
rep(i, n) cin >> a.at(i) >> b.at(i) >> c.at(i);
dp[0][0] = 0;
dp[0][1] = 0;
dp[0][2] = 0;
rep(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]);
}
rep(i, 3) ans = max(ans, dp[n][i]);
cout << ans << endl;
}
| [
"expression.operation.binary.remove"
] | 963,967 | 963,968 | u059207724 | cpp |
p03162 | #include <bits/stdc++.h>
#define all(x) (x).begin(), (x).end()
typedef long long ll;
#define rep(i, n) for (ll i = 0, i##_len = (n); i < i##_len; ++i)
#define REP(i, num, n) for (ll i = num, i##_len = (n); i < i##_len; ++i)
#define repprev(i, a, b) for (ll i = b - 1; i >= a; i--)
#define reprev(i, n) repprev(i, 0, n)
using namespace std;
#define sz(x) ((int)(x).size())
#define ZERO(a) memset(a, 0, sizeof(a))
#define MINUS(a) memset(a, 0xff, sizeof(a))
#define MEMSET(v, h) memset((v), h, sizeof(v))
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <class T> int former(const vector<T> &v, T x) {
return upper_bound(v.begin(), v.end(), x) - v.begin() - 1;
}
template <class T> int latter(const vector<T> &v, T x) {
return lower_bound(v.begin(), v.end(), x) - v.begin();
}
#define pb push_back
#define mp make_pair
#define y0 y3487465
#define y1 y8687969
#define j0 j1347829
#define j1 j234892
#define BIT_FLAG_0 (1 << 0) // 0000 0000 0000 0001
#define BIT_FLAG_1 (1 << 1) // 0000 0000 0000 0010
#define BIT_FLAG_2 (1 << 2) // 0000 0000 0000 0100
#define BIT_FLAG_3 (1 << 3) // 0000 0000 0000 1000
#define BIT_FLAG_4 (1 << 4) // 0000 0000 0001 0000
#define BIT_FLAG_5 (1 << 5) // 0000 0000 0010 0000
#define BIT_FLAG_6 (1 << 6) // 0000 0000 0100 0000
#define BIT_FLAG_7 (1 << 7) // 0000 0000 1000 0000
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
const ll LLINF = 1LL << 60;
const int INTINF = 1 << 30;
const int MAX = 510000;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
struct UnionFind {
vector<ll> par; // par[i]:iの親の番号 (例) par[3] = 2 : 3の親が2
UnionFind(ll n) : par(n, -1) {}
void init(ll n) { par.assign(n, -1); }
ll root(ll x) {
if (par[x] < 0)
return x;
else
return par[x] = root(par[x]);
}
bool issame(ll x, ll y) { return root(x) == root(y); }
bool merge(ll x, ll y) {
x = root(x);
y = root(y);
if (x == y)
return false;
if (par[x] > par[y])
swap(x, y); // merge technique
par[x] += par[y];
par[y] = x;
return true;
}
ll size(ll x) { return -par[root(x)]; }
};
template <typename T>
vector<T> dijkstra(int s, vector<vector<pair<int, T>>> &G) {
const T INF = numeric_limits<T>::max();
using P = pair<T, int>;
int n = G.size();
vector<T> d(n, INF);
vector<int> b(n, -1);
priority_queue<P, vector<P>, greater<P>> q;
d[s] = 0;
q.emplace(d[s], s);
while (!q.empty()) {
P p = q.top();
q.pop();
int v = p.second;
if (d[v] < p.first)
continue;
for (auto &e : G[v]) {
int u = e.first;
T c = e.second;
if (d[u] > d[v] + c) {
d[u] = d[v] + c;
b[u] = v;
q.emplace(d[u], u);
}
}
}
return d;
}
vector<vector<int>> bfs(vector<string> &s, int sy, int sx, char wall, int dir) {
int h = s.size(), w = s.front().size();
vector<vector<int>> dp(h, vector<int>(w, -1));
using P = pair<int, int>;
queue<P> q;
dp[sy][sx] = 0;
q.emplace(sy, sx);
int dy[] = {1, -1, 0, 0, 1, 1, -1, -1};
int dx[] = {0, 0, 1, -1, 1, -1, 1, -1};
auto in = [&](int y, int x) { return 0 <= y && y < h && 0 <= x && x < w; };
while (!q.empty()) {
int y, x;
tie(y, x) = q.front();
q.pop();
for (int k = 0; k < dir; k++) {
int ny = y + dy[k], nx = x + dx[k];
if (!in(ny, nx) || s[ny][nx] == wall)
continue;
if (~dp[ny][nx])
continue;
dp[ny][nx] = dp[y][x] + 1;
q.emplace(ny, nx);
}
}
return dp;
}
int64_t power(int64_t x, int64_t n, int64_t mod) {
int64_t ret = 1;
while (n > 0) {
if (n & 1)
(ret *= x) %= mod;
(x *= x) %= mod;
n >>= 1;
}
return ret;
}
vector<int> sieve_of_eratosthenes(int n) {
vector<int> primes(n);
for (int i = 2; i < n; ++i)
primes[i] = i;
for (int i = 2; i * i < n; ++i)
if (primes[i])
for (int j = i * i; j < n; j += i)
primes[j] = 0;
return primes;
}
struct Dice {
int s[6];
int &top() { return s[0]; }
int &south() { return s[1]; }
int &east() { return s[2]; }
int &west() { return s[3]; }
int &north() { return s[4]; }
int &bottom() { return s[5]; }
void roll(char c) {
// the view from above
// N
// W E
// S
string b("EWNSRL");
int v[6][4] = {{0, 3, 5, 2}, {0, 2, 5, 3}, {0, 1, 5, 4},
{0, 4, 5, 1}, {1, 2, 4, 3}, {1, 3, 4, 2}};
for (int k = 0; k < 6; k++) {
if (b[k] != c)
continue;
int t = s[v[k][0]];
s[v[k][0]] = s[v[k][1]];
s[v[k][1]] = s[v[k][2]];
s[v[k][2]] = s[v[k][3]];
s[v[k][3]] = t;
}
}
using ll = long long;
ll hash() {
ll res = 0;
for (int i = 0; i < 6; i++)
res = res * 256 + s[i];
return res;
}
bool operator==(const Dice &d) const {
for (int i = 0; i < 6; i++)
if (s[i] != d.s[i])
return 0;
return 1;
}
};
vector<Dice> makeDices(Dice d) {
vector<Dice> res;
for (int i = 0; i < 6; i++) {
Dice t(d);
if (i == 1)
t.roll('N');
if (i == 2)
t.roll('S');
if (i == 3)
t.roll('S'), t.roll('S');
if (i == 4)
t.roll('L');
if (i == 5)
t.roll('R');
for (int k = 0; k < 4; k++) {
res.push_back(t);
t.roll('E');
}
}
return res;
}
std::vector<ll> divisor(ll n) // nの約数を列挙
{
std::vector<ll> ret;
for (ll i = 1; i * i <= n; ++i) {
if (n % i == 0) {
ret.push_back(i);
if (i != 1 && i * i != n) {
ret.push_back(n / i);
}
}
}
return ret;
}
// 多次元 vector 生成
template <class T> vector<T> make_vec(size_t a) { return vector<T>(a); }
template <class T, class... Ts> auto make_vec(size_t a, Ts... ts) {
return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}
using Graph = vector<vector<int>>;
// 深さ優先探索
vector<bool> seen;
void gdfs(const Graph &G, int v) {
seen[v] = true; // v を訪問済にする
// v から行ける各頂点 next_v について
for (auto next_v : G[v]) {
if (seen[next_v])
continue; // next_v が探索済だったらスルー
gdfs(G, next_v); // 再帰的に探索
}
}
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
const string MINUSINF = "-";
void Cmax(string &a, string b) {
if (a == MINUSINF)
a = b;
else if (a.size() < b.size())
a = b;
else if (a.size() == b.size()) {
if (a < b)
a = b;
}
}
int N;
ll a[100010][3];
ll dp[100010][3];
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> N;
rep(i, N) rep(j, 3) cin >> a[i][j];
rep(i, N) {
rep(j, 3) {
rep(k, 3) {
if (j == k)
continue;
chmax(dp[i + 1][k], dp[i][j] + a[i][k]);
}
}
}
ll ans = 0;
rep(j, 3) chmax(ans, dp[N - 1][j]);
cout << ans << endl;
}
| #include <bits/stdc++.h>
#define all(x) (x).begin(), (x).end()
typedef long long ll;
#define rep(i, n) for (ll i = 0, i##_len = (n); i < i##_len; ++i)
#define REP(i, num, n) for (ll i = num, i##_len = (n); i < i##_len; ++i)
#define repprev(i, a, b) for (ll i = b - 1; i >= a; i--)
#define reprev(i, n) repprev(i, 0, n)
using namespace std;
#define sz(x) ((int)(x).size())
#define ZERO(a) memset(a, 0, sizeof(a))
#define MINUS(a) memset(a, 0xff, sizeof(a))
#define MEMSET(v, h) memset((v), h, sizeof(v))
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <class T> int former(const vector<T> &v, T x) {
return upper_bound(v.begin(), v.end(), x) - v.begin() - 1;
}
template <class T> int latter(const vector<T> &v, T x) {
return lower_bound(v.begin(), v.end(), x) - v.begin();
}
#define pb push_back
#define mp make_pair
#define y0 y3487465
#define y1 y8687969
#define j0 j1347829
#define j1 j234892
#define BIT_FLAG_0 (1 << 0) // 0000 0000 0000 0001
#define BIT_FLAG_1 (1 << 1) // 0000 0000 0000 0010
#define BIT_FLAG_2 (1 << 2) // 0000 0000 0000 0100
#define BIT_FLAG_3 (1 << 3) // 0000 0000 0000 1000
#define BIT_FLAG_4 (1 << 4) // 0000 0000 0001 0000
#define BIT_FLAG_5 (1 << 5) // 0000 0000 0010 0000
#define BIT_FLAG_6 (1 << 6) // 0000 0000 0100 0000
#define BIT_FLAG_7 (1 << 7) // 0000 0000 1000 0000
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
const ll LLINF = 1LL << 60;
const int INTINF = 1 << 30;
const int MAX = 510000;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
struct UnionFind {
vector<ll> par; // par[i]:iの親の番号 (例) par[3] = 2 : 3の親が2
UnionFind(ll n) : par(n, -1) {}
void init(ll n) { par.assign(n, -1); }
ll root(ll x) {
if (par[x] < 0)
return x;
else
return par[x] = root(par[x]);
}
bool issame(ll x, ll y) { return root(x) == root(y); }
bool merge(ll x, ll y) {
x = root(x);
y = root(y);
if (x == y)
return false;
if (par[x] > par[y])
swap(x, y); // merge technique
par[x] += par[y];
par[y] = x;
return true;
}
ll size(ll x) { return -par[root(x)]; }
};
template <typename T>
vector<T> dijkstra(int s, vector<vector<pair<int, T>>> &G) {
const T INF = numeric_limits<T>::max();
using P = pair<T, int>;
int n = G.size();
vector<T> d(n, INF);
vector<int> b(n, -1);
priority_queue<P, vector<P>, greater<P>> q;
d[s] = 0;
q.emplace(d[s], s);
while (!q.empty()) {
P p = q.top();
q.pop();
int v = p.second;
if (d[v] < p.first)
continue;
for (auto &e : G[v]) {
int u = e.first;
T c = e.second;
if (d[u] > d[v] + c) {
d[u] = d[v] + c;
b[u] = v;
q.emplace(d[u], u);
}
}
}
return d;
}
vector<vector<int>> bfs(vector<string> &s, int sy, int sx, char wall, int dir) {
int h = s.size(), w = s.front().size();
vector<vector<int>> dp(h, vector<int>(w, -1));
using P = pair<int, int>;
queue<P> q;
dp[sy][sx] = 0;
q.emplace(sy, sx);
int dy[] = {1, -1, 0, 0, 1, 1, -1, -1};
int dx[] = {0, 0, 1, -1, 1, -1, 1, -1};
auto in = [&](int y, int x) { return 0 <= y && y < h && 0 <= x && x < w; };
while (!q.empty()) {
int y, x;
tie(y, x) = q.front();
q.pop();
for (int k = 0; k < dir; k++) {
int ny = y + dy[k], nx = x + dx[k];
if (!in(ny, nx) || s[ny][nx] == wall)
continue;
if (~dp[ny][nx])
continue;
dp[ny][nx] = dp[y][x] + 1;
q.emplace(ny, nx);
}
}
return dp;
}
int64_t power(int64_t x, int64_t n, int64_t mod) {
int64_t ret = 1;
while (n > 0) {
if (n & 1)
(ret *= x) %= mod;
(x *= x) %= mod;
n >>= 1;
}
return ret;
}
vector<int> sieve_of_eratosthenes(int n) {
vector<int> primes(n);
for (int i = 2; i < n; ++i)
primes[i] = i;
for (int i = 2; i * i < n; ++i)
if (primes[i])
for (int j = i * i; j < n; j += i)
primes[j] = 0;
return primes;
}
struct Dice {
int s[6];
int &top() { return s[0]; }
int &south() { return s[1]; }
int &east() { return s[2]; }
int &west() { return s[3]; }
int &north() { return s[4]; }
int &bottom() { return s[5]; }
void roll(char c) {
// the view from above
// N
// W E
// S
string b("EWNSRL");
int v[6][4] = {{0, 3, 5, 2}, {0, 2, 5, 3}, {0, 1, 5, 4},
{0, 4, 5, 1}, {1, 2, 4, 3}, {1, 3, 4, 2}};
for (int k = 0; k < 6; k++) {
if (b[k] != c)
continue;
int t = s[v[k][0]];
s[v[k][0]] = s[v[k][1]];
s[v[k][1]] = s[v[k][2]];
s[v[k][2]] = s[v[k][3]];
s[v[k][3]] = t;
}
}
using ll = long long;
ll hash() {
ll res = 0;
for (int i = 0; i < 6; i++)
res = res * 256 + s[i];
return res;
}
bool operator==(const Dice &d) const {
for (int i = 0; i < 6; i++)
if (s[i] != d.s[i])
return 0;
return 1;
}
};
vector<Dice> makeDices(Dice d) {
vector<Dice> res;
for (int i = 0; i < 6; i++) {
Dice t(d);
if (i == 1)
t.roll('N');
if (i == 2)
t.roll('S');
if (i == 3)
t.roll('S'), t.roll('S');
if (i == 4)
t.roll('L');
if (i == 5)
t.roll('R');
for (int k = 0; k < 4; k++) {
res.push_back(t);
t.roll('E');
}
}
return res;
}
std::vector<ll> divisor(ll n) // nの約数を列挙
{
std::vector<ll> ret;
for (ll i = 1; i * i <= n; ++i) {
if (n % i == 0) {
ret.push_back(i);
if (i != 1 && i * i != n) {
ret.push_back(n / i);
}
}
}
return ret;
}
// 多次元 vector 生成
template <class T> vector<T> make_vec(size_t a) { return vector<T>(a); }
template <class T, class... Ts> auto make_vec(size_t a, Ts... ts) {
return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}
using Graph = vector<vector<int>>;
// 深さ優先探索
vector<bool> seen;
void gdfs(const Graph &G, int v) {
seen[v] = true; // v を訪問済にする
// v から行ける各頂点 next_v について
for (auto next_v : G[v]) {
if (seen[next_v])
continue; // next_v が探索済だったらスルー
gdfs(G, next_v); // 再帰的に探索
}
}
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
const string MINUSINF = "-";
void Cmax(string &a, string b) {
if (a == MINUSINF)
a = b;
else if (a.size() < b.size())
a = b;
else if (a.size() == b.size()) {
if (a < b)
a = b;
}
}
int N;
ll a[100010][3];
ll dp[100010][3];
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> N;
rep(i, N) rep(j, 3) cin >> a[i][j];
rep(i, N) {
rep(j, 3) {
rep(k, 3) {
if (j == k)
continue;
chmax(dp[i + 1][k], dp[i][j] + a[i][k]);
}
}
}
ll ans = 0;
rep(j, 3) chmax(ans, dp[N][j]);
cout << ans << endl;
}
| [
"expression.operation.binary.remove"
] | 963,969 | 963,970 | u135572611 | cpp |
p03162 | #include <bits/stdc++.h>
#define all(x) (x).begin(), (x).end()
typedef long long ll;
#define rep(i, n) for (ll i = 0, i##_len = (n); i < i##_len; ++i)
#define REP(i, num, n) for (ll i = num, i##_len = (n); i < i##_len; ++i)
#define repprev(i, a, b) for (ll i = b - 1; i >= a; i--)
#define reprev(i, n) repprev(i, 0, n)
using namespace std;
#define sz(x) ((int)(x).size())
#define ZERO(a) memset(a, 0, sizeof(a))
#define MINUS(a) memset(a, 0xff, sizeof(a))
#define MEMSET(v, h) memset((v), h, sizeof(v))
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <class T> int former(const vector<T> &v, T x) {
return upper_bound(v.begin(), v.end(), x) - v.begin() - 1;
}
template <class T> int latter(const vector<T> &v, T x) {
return lower_bound(v.begin(), v.end(), x) - v.begin();
}
#define pb push_back
#define mp make_pair
#define y0 y3487465
#define y1 y8687969
#define j0 j1347829
#define j1 j234892
#define BIT_FLAG_0 (1 << 0) // 0000 0000 0000 0001
#define BIT_FLAG_1 (1 << 1) // 0000 0000 0000 0010
#define BIT_FLAG_2 (1 << 2) // 0000 0000 0000 0100
#define BIT_FLAG_3 (1 << 3) // 0000 0000 0000 1000
#define BIT_FLAG_4 (1 << 4) // 0000 0000 0001 0000
#define BIT_FLAG_5 (1 << 5) // 0000 0000 0010 0000
#define BIT_FLAG_6 (1 << 6) // 0000 0000 0100 0000
#define BIT_FLAG_7 (1 << 7) // 0000 0000 1000 0000
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
const ll LLINF = 1LL << 60;
const int INTINF = 1 << 30;
const int MAX = 510000;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
struct UnionFind {
vector<ll> par; // par[i]:iの親の番号 (例) par[3] = 2 : 3の親が2
UnionFind(ll n) : par(n, -1) {}
void init(ll n) { par.assign(n, -1); }
ll root(ll x) {
if (par[x] < 0)
return x;
else
return par[x] = root(par[x]);
}
bool issame(ll x, ll y) { return root(x) == root(y); }
bool merge(ll x, ll y) {
x = root(x);
y = root(y);
if (x == y)
return false;
if (par[x] > par[y])
swap(x, y); // merge technique
par[x] += par[y];
par[y] = x;
return true;
}
ll size(ll x) { return -par[root(x)]; }
};
template <typename T>
vector<T> dijkstra(int s, vector<vector<pair<int, T>>> &G) {
const T INF = numeric_limits<T>::max();
using P = pair<T, int>;
int n = G.size();
vector<T> d(n, INF);
vector<int> b(n, -1);
priority_queue<P, vector<P>, greater<P>> q;
d[s] = 0;
q.emplace(d[s], s);
while (!q.empty()) {
P p = q.top();
q.pop();
int v = p.second;
if (d[v] < p.first)
continue;
for (auto &e : G[v]) {
int u = e.first;
T c = e.second;
if (d[u] > d[v] + c) {
d[u] = d[v] + c;
b[u] = v;
q.emplace(d[u], u);
}
}
}
return d;
}
vector<vector<int>> bfs(vector<string> &s, int sy, int sx, char wall, int dir) {
int h = s.size(), w = s.front().size();
vector<vector<int>> dp(h, vector<int>(w, -1));
using P = pair<int, int>;
queue<P> q;
dp[sy][sx] = 0;
q.emplace(sy, sx);
int dy[] = {1, -1, 0, 0, 1, 1, -1, -1};
int dx[] = {0, 0, 1, -1, 1, -1, 1, -1};
auto in = [&](int y, int x) { return 0 <= y && y < h && 0 <= x && x < w; };
while (!q.empty()) {
int y, x;
tie(y, x) = q.front();
q.pop();
for (int k = 0; k < dir; k++) {
int ny = y + dy[k], nx = x + dx[k];
if (!in(ny, nx) || s[ny][nx] == wall)
continue;
if (~dp[ny][nx])
continue;
dp[ny][nx] = dp[y][x] + 1;
q.emplace(ny, nx);
}
}
return dp;
}
int64_t power(int64_t x, int64_t n, int64_t mod) {
int64_t ret = 1;
while (n > 0) {
if (n & 1)
(ret *= x) %= mod;
(x *= x) %= mod;
n >>= 1;
}
return ret;
}
vector<int> sieve_of_eratosthenes(int n) {
vector<int> primes(n);
for (int i = 2; i < n; ++i)
primes[i] = i;
for (int i = 2; i * i < n; ++i)
if (primes[i])
for (int j = i * i; j < n; j += i)
primes[j] = 0;
return primes;
}
struct Dice {
int s[6];
int &top() { return s[0]; }
int &south() { return s[1]; }
int &east() { return s[2]; }
int &west() { return s[3]; }
int &north() { return s[4]; }
int &bottom() { return s[5]; }
void roll(char c) {
// the view from above
// N
// W E
// S
string b("EWNSRL");
int v[6][4] = {{0, 3, 5, 2}, {0, 2, 5, 3}, {0, 1, 5, 4},
{0, 4, 5, 1}, {1, 2, 4, 3}, {1, 3, 4, 2}};
for (int k = 0; k < 6; k++) {
if (b[k] != c)
continue;
int t = s[v[k][0]];
s[v[k][0]] = s[v[k][1]];
s[v[k][1]] = s[v[k][2]];
s[v[k][2]] = s[v[k][3]];
s[v[k][3]] = t;
}
}
using ll = long long;
ll hash() {
ll res = 0;
for (int i = 0; i < 6; i++)
res = res * 256 + s[i];
return res;
}
bool operator==(const Dice &d) const {
for (int i = 0; i < 6; i++)
if (s[i] != d.s[i])
return 0;
return 1;
}
};
vector<Dice> makeDices(Dice d) {
vector<Dice> res;
for (int i = 0; i < 6; i++) {
Dice t(d);
if (i == 1)
t.roll('N');
if (i == 2)
t.roll('S');
if (i == 3)
t.roll('S'), t.roll('S');
if (i == 4)
t.roll('L');
if (i == 5)
t.roll('R');
for (int k = 0; k < 4; k++) {
res.push_back(t);
t.roll('E');
}
}
return res;
}
std::vector<ll> divisor(ll n) // nの約数を列挙
{
std::vector<ll> ret;
for (ll i = 1; i * i <= n; ++i) {
if (n % i == 0) {
ret.push_back(i);
if (i != 1 && i * i != n) {
ret.push_back(n / i);
}
}
}
return ret;
}
// 多次元 vector 生成
template <class T> vector<T> make_vec(size_t a) { return vector<T>(a); }
template <class T, class... Ts> auto make_vec(size_t a, Ts... ts) {
return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}
using Graph = vector<vector<int>>;
// 深さ優先探索
vector<bool> seen;
void gdfs(const Graph &G, int v) {
seen[v] = true; // v を訪問済にする
// v から行ける各頂点 next_v について
for (auto next_v : G[v]) {
if (seen[next_v])
continue; // next_v が探索済だったらスルー
gdfs(G, next_v); // 再帰的に探索
}
}
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
const string MINUSINF = "-";
void Cmax(string &a, string b) {
if (a == MINUSINF)
a = b;
else if (a.size() < b.size())
a = b;
else if (a.size() == b.size()) {
if (a < b)
a = b;
}
}
int N;
ll a[100010][3];
ll dp[100010][3];
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
rep(i, N) rep(j, 3) cin >> a[i][j];
rep(i, N) {
rep(j, 3) {
rep(k, 3) {
if (j == k)
continue;
chmax(dp[i + 1][k], dp[i][j] + a[i][k]);
}
}
}
ll ans = 0;
rep(j, 3) chmax(ans, dp[N][j]);
cout << ans << endl;
}
| #include <bits/stdc++.h>
#define all(x) (x).begin(), (x).end()
typedef long long ll;
#define rep(i, n) for (ll i = 0, i##_len = (n); i < i##_len; ++i)
#define REP(i, num, n) for (ll i = num, i##_len = (n); i < i##_len; ++i)
#define repprev(i, a, b) for (ll i = b - 1; i >= a; i--)
#define reprev(i, n) repprev(i, 0, n)
using namespace std;
#define sz(x) ((int)(x).size())
#define ZERO(a) memset(a, 0, sizeof(a))
#define MINUS(a) memset(a, 0xff, sizeof(a))
#define MEMSET(v, h) memset((v), h, sizeof(v))
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <class T> int former(const vector<T> &v, T x) {
return upper_bound(v.begin(), v.end(), x) - v.begin() - 1;
}
template <class T> int latter(const vector<T> &v, T x) {
return lower_bound(v.begin(), v.end(), x) - v.begin();
}
#define pb push_back
#define mp make_pair
#define y0 y3487465
#define y1 y8687969
#define j0 j1347829
#define j1 j234892
#define BIT_FLAG_0 (1 << 0) // 0000 0000 0000 0001
#define BIT_FLAG_1 (1 << 1) // 0000 0000 0000 0010
#define BIT_FLAG_2 (1 << 2) // 0000 0000 0000 0100
#define BIT_FLAG_3 (1 << 3) // 0000 0000 0000 1000
#define BIT_FLAG_4 (1 << 4) // 0000 0000 0001 0000
#define BIT_FLAG_5 (1 << 5) // 0000 0000 0010 0000
#define BIT_FLAG_6 (1 << 6) // 0000 0000 0100 0000
#define BIT_FLAG_7 (1 << 7) // 0000 0000 1000 0000
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
const ll LLINF = 1LL << 60;
const int INTINF = 1 << 30;
const int MAX = 510000;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
struct UnionFind {
vector<ll> par; // par[i]:iの親の番号 (例) par[3] = 2 : 3の親が2
UnionFind(ll n) : par(n, -1) {}
void init(ll n) { par.assign(n, -1); }
ll root(ll x) {
if (par[x] < 0)
return x;
else
return par[x] = root(par[x]);
}
bool issame(ll x, ll y) { return root(x) == root(y); }
bool merge(ll x, ll y) {
x = root(x);
y = root(y);
if (x == y)
return false;
if (par[x] > par[y])
swap(x, y); // merge technique
par[x] += par[y];
par[y] = x;
return true;
}
ll size(ll x) { return -par[root(x)]; }
};
template <typename T>
vector<T> dijkstra(int s, vector<vector<pair<int, T>>> &G) {
const T INF = numeric_limits<T>::max();
using P = pair<T, int>;
int n = G.size();
vector<T> d(n, INF);
vector<int> b(n, -1);
priority_queue<P, vector<P>, greater<P>> q;
d[s] = 0;
q.emplace(d[s], s);
while (!q.empty()) {
P p = q.top();
q.pop();
int v = p.second;
if (d[v] < p.first)
continue;
for (auto &e : G[v]) {
int u = e.first;
T c = e.second;
if (d[u] > d[v] + c) {
d[u] = d[v] + c;
b[u] = v;
q.emplace(d[u], u);
}
}
}
return d;
}
vector<vector<int>> bfs(vector<string> &s, int sy, int sx, char wall, int dir) {
int h = s.size(), w = s.front().size();
vector<vector<int>> dp(h, vector<int>(w, -1));
using P = pair<int, int>;
queue<P> q;
dp[sy][sx] = 0;
q.emplace(sy, sx);
int dy[] = {1, -1, 0, 0, 1, 1, -1, -1};
int dx[] = {0, 0, 1, -1, 1, -1, 1, -1};
auto in = [&](int y, int x) { return 0 <= y && y < h && 0 <= x && x < w; };
while (!q.empty()) {
int y, x;
tie(y, x) = q.front();
q.pop();
for (int k = 0; k < dir; k++) {
int ny = y + dy[k], nx = x + dx[k];
if (!in(ny, nx) || s[ny][nx] == wall)
continue;
if (~dp[ny][nx])
continue;
dp[ny][nx] = dp[y][x] + 1;
q.emplace(ny, nx);
}
}
return dp;
}
int64_t power(int64_t x, int64_t n, int64_t mod) {
int64_t ret = 1;
while (n > 0) {
if (n & 1)
(ret *= x) %= mod;
(x *= x) %= mod;
n >>= 1;
}
return ret;
}
vector<int> sieve_of_eratosthenes(int n) {
vector<int> primes(n);
for (int i = 2; i < n; ++i)
primes[i] = i;
for (int i = 2; i * i < n; ++i)
if (primes[i])
for (int j = i * i; j < n; j += i)
primes[j] = 0;
return primes;
}
struct Dice {
int s[6];
int &top() { return s[0]; }
int &south() { return s[1]; }
int &east() { return s[2]; }
int &west() { return s[3]; }
int &north() { return s[4]; }
int &bottom() { return s[5]; }
void roll(char c) {
// the view from above
// N
// W E
// S
string b("EWNSRL");
int v[6][4] = {{0, 3, 5, 2}, {0, 2, 5, 3}, {0, 1, 5, 4},
{0, 4, 5, 1}, {1, 2, 4, 3}, {1, 3, 4, 2}};
for (int k = 0; k < 6; k++) {
if (b[k] != c)
continue;
int t = s[v[k][0]];
s[v[k][0]] = s[v[k][1]];
s[v[k][1]] = s[v[k][2]];
s[v[k][2]] = s[v[k][3]];
s[v[k][3]] = t;
}
}
using ll = long long;
ll hash() {
ll res = 0;
for (int i = 0; i < 6; i++)
res = res * 256 + s[i];
return res;
}
bool operator==(const Dice &d) const {
for (int i = 0; i < 6; i++)
if (s[i] != d.s[i])
return 0;
return 1;
}
};
vector<Dice> makeDices(Dice d) {
vector<Dice> res;
for (int i = 0; i < 6; i++) {
Dice t(d);
if (i == 1)
t.roll('N');
if (i == 2)
t.roll('S');
if (i == 3)
t.roll('S'), t.roll('S');
if (i == 4)
t.roll('L');
if (i == 5)
t.roll('R');
for (int k = 0; k < 4; k++) {
res.push_back(t);
t.roll('E');
}
}
return res;
}
std::vector<ll> divisor(ll n) // nの約数を列挙
{
std::vector<ll> ret;
for (ll i = 1; i * i <= n; ++i) {
if (n % i == 0) {
ret.push_back(i);
if (i != 1 && i * i != n) {
ret.push_back(n / i);
}
}
}
return ret;
}
// 多次元 vector 生成
template <class T> vector<T> make_vec(size_t a) { return vector<T>(a); }
template <class T, class... Ts> auto make_vec(size_t a, Ts... ts) {
return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}
using Graph = vector<vector<int>>;
// 深さ優先探索
vector<bool> seen;
void gdfs(const Graph &G, int v) {
seen[v] = true; // v を訪問済にする
// v から行ける各頂点 next_v について
for (auto next_v : G[v]) {
if (seen[next_v])
continue; // next_v が探索済だったらスルー
gdfs(G, next_v); // 再帰的に探索
}
}
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
const string MINUSINF = "-";
void Cmax(string &a, string b) {
if (a == MINUSINF)
a = b;
else if (a.size() < b.size())
a = b;
else if (a.size() == b.size()) {
if (a < b)
a = b;
}
}
int N;
ll a[100010][3];
ll dp[100010][3];
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> N;
rep(i, N) rep(j, 3) cin >> a[i][j];
rep(i, N) {
rep(j, 3) {
rep(k, 3) {
if (j == k)
continue;
chmax(dp[i + 1][k], dp[i][j] + a[i][k]);
}
}
}
ll ans = 0;
rep(j, 3) chmax(ans, dp[N][j]);
cout << ans << endl;
}
| [] | 963,971 | 963,970 | u135572611 | cpp |
p03162 | #include <bits/stdc++.h>
#include <iostream>
#include <vector>
using namespace std;
int main() {
// your code goes here
int n;
cin >> n;
vector<int> dp(3, 0);
for (int i = 0; i < n; i++) {
vector<int> c(3);
vector<int> temp_dp(3, 0);
cin >> c[0] >> c[1] >> c[2];
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (i != j) {
temp_dp[i] = max(temp_dp[i], dp[i] + c[j]);
}
}
}
dp = temp_dp;
}
cout << max({dp[0], dp[1], dp[2]}) << endl;
return 0;
} | #include <bits/stdc++.h>
#include <iostream>
#include <vector>
using namespace std;
int main() {
// your code goes here
int n;
cin >> n;
vector<int> dp(3);
for (int i = 0; i < n; i++) {
vector<int> c(3);
vector<int> temp_dp(3, 0);
cin >> c[0] >> c[1] >> c[2];
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (i != j) {
temp_dp[j] = max(temp_dp[j], dp[i] + c[j]);
}
}
}
dp = temp_dp;
}
// cout<<dp[0]<<dp[1]<<dp[2]<<endl;
cout << max({dp[0], dp[1], dp[2]}) << endl;
return 0;
} | [
"call.arguments.change",
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change",
"assignment.value.change"
] | 963,977 | 963,978 | u819054341 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
const long double PI = acos(-1);
typedef long long ll;
typedef pair<int64_t, int64_t> pll;
int dx[] = {1, -1, 0, 0, 1, -1, 1, -1};
int dy[] = {0, 0, 1, -1, 1, -1, -1, 1};
#define INF (2147483647)
#define mod (1000000007)
#define limit (7368791)
#define rep(i, a, b) for (int64_t i = (a); i < (b); i++)
#define REP(i, n) rep(i, 0, n)
#define ALL(a) begin(a), end(a)
#define sz(s) (s).size()
#define pb push_back
#define mp make_pair
#define fi first
#define se second
void solve() {
int n;
cin >> n;
vector<vector<int>> dp(n, vector<int>(3, 0));
REP(i, 3) cin >> dp[0][i];
rep(i, 1, n) {
int abc[3];
REP(i, 3) cin >> abc[i];
REP(j, 3)
rep(k, j + 1, j + 3) dp[i][j] = max(dp[i][j], dp[i - 1][k] + abc[k]);
}
int ans = 0;
REP(i, 3) ans = max(ans, dp[n - 1][i]);
cout << ans << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const long double PI = acos(-1);
typedef long long ll;
typedef pair<int64_t, int64_t> pll;
int dx[] = {1, -1, 0, 0, 1, -1, 1, -1};
int dy[] = {0, 0, 1, -1, 1, -1, -1, 1};
#define INF (2147483647)
#define mod (1000000007)
#define limit (7368791)
#define rep(i, a, b) for (int64_t i = (a); i < (b); i++)
#define REP(i, n) rep(i, 0, n)
#define ALL(a) begin(a), end(a)
#define sz(s) (s).size()
#define pb push_back
#define mp make_pair
#define fi first
#define se second
void solve() {
int n;
cin >> n;
vector<vector<int>> dp(n, vector<int>(3, 0));
REP(i, 3) cin >> dp[0][i];
rep(i, 1, n) {
int abc[3];
REP(i, 3) cin >> abc[i];
REP(j, 3)
rep(k, j + 1, j + 3) dp[i][j] = max(dp[i][j], dp[i - 1][k % 3] + abc[j]);
}
int ans = 0;
REP(i, 3) ans = max(ans, dp[n - 1][i]);
cout << ans << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
} | [
"assignment.change",
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 963,985 | 963,986 | u973991908 | cpp |
p03162 | // define debug for debugging
#define DEBUG
#include <bits/stdc++.h>
using namespace std;
#define F first
#define S second
#define pb push_back
#define mp make_pair
#define MOD 1000000007
#define MAX 100000 + 100
#define max3(a, b, c) max(a, max(b, c))
typedef long long int ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
int n, cevap = -1;
int arr[MAX][3], dp[MAX][3][3];
void dfs(int a, int b, int c) {
if (a == -1) {
dfs(0, 0, 1);
dfs(0, 1, 2);
dfs(0, 2, 0);
cevap = max3(dp[0][0][1], dp[0][1][2], dp[0][2][0]);
} else if (dp[a][b][c] == 0) {
int mn = 0;
if (a + 1 < n) {
if (c != 0) {
dfs(a + 1, c, 0);
mn = dp[a + 1][c][0];
}
if (c != 1) {
dfs(a + 1, c, 1);
mn = max(mn, dp[a + 1][c][1]);
}
if (c != 2) {
dfs(a + 1, c, 2);
mn = max(mn, dp[a + 1][c][2]);
}
} else
mn = 0;
dp[a][b][c] = mn + arr[a][c];
// cout << a << ' ' << b << ' ' << c << ' ' << dp[a][b][c] << ' ' << mn <<
// ' ' << arr[a][c] << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#ifdef DEBUG
freopen("i.txt", "r", stdin);
freopen("o.txt", "w", stdout);
#endif
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i][0] >> arr[i][1] >> arr[i][2];
}
dfs(-1, -1, -1);
cout << cevap;
return 0;
}
| // define debug for debugging
//#define DEBUG
#include <bits/stdc++.h>
using namespace std;
#define F first
#define S second
#define pb push_back
#define mp make_pair
#define MOD 1000000007
#define MAX 100000 + 100
#define max3(a, b, c) max(a, max(b, c))
typedef long long int ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
int n, cevap = -1;
int arr[MAX][3], dp[MAX][3][3];
void dfs(int a, int b, int c) {
if (a == -1) {
dfs(0, 0, 1);
dfs(0, 1, 2);
dfs(0, 2, 0);
cevap = max3(dp[0][0][1], dp[0][1][2], dp[0][2][0]);
} else if (dp[a][b][c] == 0) {
int mn = 0;
if (a + 1 < n) {
if (c != 0) {
dfs(a + 1, c, 0);
mn = dp[a + 1][c][0];
}
if (c != 1) {
dfs(a + 1, c, 1);
mn = max(mn, dp[a + 1][c][1]);
}
if (c != 2) {
dfs(a + 1, c, 2);
mn = max(mn, dp[a + 1][c][2]);
}
} else
mn = 0;
dp[a][b][c] = mn + arr[a][c];
// cout << a << ' ' << b << ' ' << c << ' ' << dp[a][b][c] << ' ' << mn <<
// ' ' << arr[a][c] << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#ifdef DEBUG
freopen("i.txt", "r", stdin);
freopen("o.txt", "w", stdout);
#endif
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i][0] >> arr[i][1] >> arr[i][2];
}
dfs(-1, -1, -1);
cout << cevap;
return 0;
}
| [] | 963,987 | 963,988 | u067401008 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define mx 100009
const ll inf = 1e18;
ll dp_array[mx][4];
ll a[mx], b[mx], c[mx], n;
ll dp(ll i, ll object) {
if (i >= n)
return 0L;
if (dp_array[i][object] != -1)
return dp_array[i][object];
ll value, value2;
if (object == 1) {
value = a[i] + dp(i + 1, 2);
value2 = a[i] + dp(i + 1, 3);
}
if (object == 2) {
value = b[i] + dp(i + 1, 1);
value2 = b[i] + dp(i + 1, 3);
}
if (object == 3) {
value = c[i] + dp(i + 1, 2);
value2 = c[i] + dp(i + 1, 1);
}
// printf("dp_array[%lld][%lld] : %lld\n",i,object,max(value,value2));
return dp_array[i][object] = (long long)max(value, value2);
}
int main() {
memset(dp_array, -1, sizeof dp_array);
scanf("%lld", &n);
for (int i = 0; i < n; i++)
scanf("%lld %lld %lld", &a[i], &b[i], &c[i]);
ll value = dp(0, 1);
ll value2 = dp(0, 2);
ll value3 = dp(0, 3);
ll ans = (long long)max(value, value);
ans = (long long)max(ans, value3);
printf("%lld\n", ans);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define mx 100009
const ll inf = 1e18;
ll dp_array[mx][4];
ll a[mx], b[mx], c[mx], n;
ll dp(ll i, ll object) {
if (i >= n)
return 0L;
if (dp_array[i][object] != -1)
return dp_array[i][object];
ll value, value2;
if (object == 1) {
value = a[i] + dp(i + 1, 2);
value2 = a[i] + dp(i + 1, 3);
}
if (object == 2) {
value = b[i] + dp(i + 1, 1);
value2 = b[i] + dp(i + 1, 3);
}
if (object == 3) {
value = c[i] + dp(i + 1, 2);
value2 = c[i] + dp(i + 1, 1);
}
// printf("dp_array[%lld][%lld] : %lld\n",i,object,max(value,value2));
return dp_array[i][object] = (long long)max(value, value2);
}
int main() {
memset(dp_array, -1, sizeof dp_array);
scanf("%lld", &n);
for (int i = 0; i < n; i++)
scanf("%lld %lld %lld", &a[i], &b[i], &c[i]);
ll value = dp(0, 1);
ll value2 = dp(0, 2);
ll value3 = dp(0, 3);
ll ans = (long long)max(value, value2);
ans = (long long)max(ans, value3);
printf("%lld\n", ans);
return 0;
}
| [
"identifier.change",
"call.arguments.change"
] | 963,991 | 963,992 | u746954503 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define mx 100009
const ll inf = 1e18;
ll dp_array[mx][4];
ll a[mx], b[mx], c[mx], n;
ll dp(ll i, ll object) {
if (i >= n)
return 0;
if (dp_array[i][object] != -1)
return dp_array[i][object];
ll value, value2;
if (object == 1) {
value = a[i] + dp(i + 1, 2);
value2 = a[i] + dp(i + 1, 3);
}
if (object == 2) {
value = b[i] + dp(i + 1, 1);
value2 = b[i] + dp(i + 1, 3);
}
if (object == 3) {
value = c[i] + dp(i + 1, 2);
value2 = c[i] + dp(i + 1, 1);
}
// printf("dp_array[%lld][%lld] : %lld\n",i,object,max(value,value2));
return dp_array[i][object] = (long long)max(value, value2);
}
int main() {
memset(dp_array, -1, sizeof dp_array);
scanf("%lld", &n);
for (int i = 0; i < n; i++)
scanf("%lld %lld %lld", &a[i], &b[i], &c[i]);
ll value = dp(0, 1);
ll value2 = dp(0, 2);
ll value3 = dp(0, 3);
ll ans = (long long)max(value, value);
ans = (long long)max(ans, value3);
printf("%lld\n", ans);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define mx 100009
const ll inf = 1e18;
ll dp_array[mx][4];
ll a[mx], b[mx], c[mx], n;
ll dp(ll i, ll object) {
if (i >= n)
return 0L;
if (dp_array[i][object] != -1)
return dp_array[i][object];
ll value, value2;
if (object == 1) {
value = a[i] + dp(i + 1, 2);
value2 = a[i] + dp(i + 1, 3);
}
if (object == 2) {
value = b[i] + dp(i + 1, 1);
value2 = b[i] + dp(i + 1, 3);
}
if (object == 3) {
value = c[i] + dp(i + 1, 2);
value2 = c[i] + dp(i + 1, 1);
}
// printf("dp_array[%lld][%lld] : %lld\n",i,object,max(value,value2));
return dp_array[i][object] = (long long)max(value, value2);
}
int main() {
memset(dp_array, -1, sizeof dp_array);
scanf("%lld", &n);
for (int i = 0; i < n; i++)
scanf("%lld %lld %lld", &a[i], &b[i], &c[i]);
ll value = dp(0, 1);
ll value2 = dp(0, 2);
ll value3 = dp(0, 3);
ll ans = (long long)max(value, value2);
ans = (long long)max(ans, value3);
printf("%lld\n", ans);
return 0;
}
| [
"literal.number.type.widen.change",
"identifier.change",
"call.arguments.change"
] | 963,993 | 963,992 | u746954503 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define f first
#define s second
#define ll long long
int n;
int dp[3][100005];
int a[3][100005]; //,b[100005],c[100005];
int dpa(int last, int n) {
if (n < 0) {
return 0;
}
if (dp[last][n] != -1) {
return dp[last][n];
}
int lcmx = -999;
for (int i = 0; i < 3; ++i) {
if (i == last) {
continue;
} else
lcmx = max(lcmx, dpa(i, n - 1) + a[i][n]);
}
// cout<<lcmx<<" ";
dp[last][n] = lcmx;
return dp[last][n];
}
int main() {
//
memset(dp, -1, sizeof(dp));
// ios_base::sync_with_stdio(false);
// cin.tie(NULL);
cin >> n;
int ans = 0;
for (int i = 0; i < n; i++) {
cin >> a[0][i] >> a[1][i] >> a[2][i];
}
ans = max((dpa(0, n - 2) + a[0][n - 1]), dpa(1, n - 2 + a[1][n - 1]));
cout << max(ans, dpa(2, n - 2) + a[2][n - 1]) << " ";
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define f first
#define s second
#define ll long long
int n;
int dp[3][100005];
int a[3][100005]; //,b[100005],c[100005];
int dpa(int last, int n) {
if (n < 0) {
return 0;
}
if (dp[last][n] != -1) {
return dp[last][n];
}
int lcmx = -999;
for (int i = 0; i < 3; ++i) {
if (i == last) {
continue;
} else
lcmx = max(lcmx, dpa(i, n - 1) + a[i][n]);
}
// cout<<lcmx<<" ";
dp[last][n] = lcmx;
return dp[last][n];
}
int main() {
memset(dp, -1, sizeof(dp));
// ios_base::sync_with_stdio(false);
// cin.tie(NULL);
cin >> n;
int ans = 0;
for (int i = 0; i < n; i++) {
cin >> a[0][i] >> a[1][i] >> a[2][i];
}
ans = max(dpa(0, n - 2) + a[0][n - 1], dpa(1, n - 2) + a[1][n - 1]);
cout << max(ans, dpa(2, n - 2) + a[2][n - 1]) << " ";
return 0;
} | [
"call.arguments.change"
] | 963,996 | 963,997 | u258931378 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define f first
#define s second
#define ll long long
int n;
int dp[3][100005];
int a[3][100005]; //,b[100005],c[100005];
int dpa(int last, int n) {
if (n < 0) {
return 0;
}
if (dp[last][n] != -1) {
return dp[last][n];
}
int lcmx = -999;
for (int i = 0; i < 3; ++i) {
if (i == last) {
continue;
} else
lcmx = max(lcmx, dpa(i, n - 1) + a[i][n]);
}
// cout<<lcmx<<" ";
dp[last][n] = lcmx;
return dp[last][n];
}
int main() {
memset(dp, -1, sizeof(dp));
// ios_base::sync_with_stdio(false);
// cin.tie(NULL);
cin >> n;
int ans = 0;
for (int i = 0; i < n; i++) {
cin >> a[0][i] >> a[1][i] >> a[2][i];
}
ans = max(dpa(0, n - 2) + a[0][n - 1], dpa(1, n - 2 + a[1][n - 1]));
cout << max(ans, dpa(2, n - 2) + a[2][n - 1]) << " ";
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define f first
#define s second
#define ll long long
int n;
int dp[3][100005];
int a[3][100005]; //,b[100005],c[100005];
int dpa(int last, int n) {
if (n < 0) {
return 0;
}
if (dp[last][n] != -1) {
return dp[last][n];
}
int lcmx = -999;
for (int i = 0; i < 3; ++i) {
if (i == last) {
continue;
} else
lcmx = max(lcmx, dpa(i, n - 1) + a[i][n]);
}
// cout<<lcmx<<" ";
dp[last][n] = lcmx;
return dp[last][n];
}
int main() {
memset(dp, -1, sizeof(dp));
// ios_base::sync_with_stdio(false);
// cin.tie(NULL);
cin >> n;
int ans = 0;
for (int i = 0; i < n; i++) {
cin >> a[0][i] >> a[1][i] >> a[2][i];
}
ans = max(dpa(0, n - 2) + a[0][n - 1], dpa(1, n - 2) + a[1][n - 1]);
cout << max(ans, dpa(2, n - 2) + a[2][n - 1]) << " ";
return 0;
} | [
"call.arguments.change"
] | 963,998 | 963,997 | u258931378 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int dp[100001][3];
vector<int> a, b, c;
int n, x, y, z;
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x >> y >> z;
a.push_back(x);
b.push_back(y);
c.push_back(z);
}
memset(dp, 0, sizeof(dp));
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][0], max(dp[i - 1][1], dp[i - 1][2]) + a[i]);
dp[i][1] = max(dp[i][1], max(dp[i - 1][0], dp[i - 1][2]) + b[i]);
dp[i][2] = max(dp[i][2], max(dp[i - 1][1], dp[i - 1][0]) + c[i]);
}
cout << max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 2][2])) << '\n';
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int dp[100001][3];
vector<int> a, b, c;
int n, x, y, z;
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x >> y >> z;
a.push_back(x);
b.push_back(y);
c.push_back(z);
}
memset(dp, 0, sizeof(dp));
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][0], max(dp[i - 1][1], dp[i - 1][2]) + a[i]);
dp[i][1] = max(dp[i][1], max(dp[i - 1][0], dp[i - 1][2]) + b[i]);
dp[i][2] = max(dp[i][2], max(dp[i - 1][0], dp[i - 1][1]) + c[i]);
}
cout << max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2])) << '\n';
return 0;
}
| [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change"
] | 964,008 | 964,009 | u365058393 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int dp[100001][3];
vector<int> a, b, c;
int n, x, y, z;
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x >> y >> z;
a.push_back(x);
b.push_back(y);
c.push_back(z);
}
memset(dp, 0, sizeof(dp));
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][0], max(dp[i - 1][1], dp[i - 1][2]) + a[i]);
dp[i][1] = max(dp[i][1], max(dp[i - 1][0], dp[i - 1][2]) + b[i]);
dp[i][2] = max(dp[i][2], max(dp[i - 1][1], dp[i - 1][2]) + c[i]);
}
cout << max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 2][2])) << '\n';
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int dp[100001][3];
vector<int> a, b, c;
int n, x, y, z;
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x >> y >> z;
a.push_back(x);
b.push_back(y);
c.push_back(z);
}
memset(dp, 0, sizeof(dp));
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][0], max(dp[i - 1][1], dp[i - 1][2]) + a[i]);
dp[i][1] = max(dp[i][1], max(dp[i - 1][0], dp[i - 1][2]) + b[i]);
dp[i][2] = max(dp[i][2], max(dp[i - 1][0], dp[i - 1][1]) + c[i]);
}
cout << max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2])) << '\n';
return 0;
}
| [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change"
] | 964,010 | 964,009 | u365058393 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> dp(3, 0);
for (int i = 0; i < n; i++) {
vector<int> c(3);
for (int j = 0; j < 3; j++)
cin >> c[i];
vector<int> new_dp(3, 0);
for (int x = 0; x < 3; x++) {
for (int y = 0; y < 3; y++) {
if (x != y) {
new_dp[x] = max(new_dp[x], dp[y] + c[x]);
}
}
}
dp = new_dp;
}
cout << max({dp[0], dp[1], dp[2]});
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> dp(3, 0);
for (int i = 0; i < n; i++) {
vector<int> c(3);
for (int j = 0; j < 3; j++)
cin >> c[j];
vector<int> new_dp(3, 0);
for (int x = 0; x < 3; ++x) {
for (int y = 0; y < 3; ++y) {
if (x != y) {
new_dp[x] = max(new_dp[x], dp[y] + c[x]);
}
}
}
dp = new_dp;
}
cout << max({dp[0], dp[1], dp[2]});
return 0;
} | [
"identifier.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 964,018 | 964,019 | u435190720 | cpp |
p03162 | #include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <stack>
#include <vector>
#define INFTY 10000000000
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int h[110000][3];
long long dp[110000][3] = {0};
for (int i = 1; i <= n; i++) {
cin >> h[i][0] >> h[i][1] >> h[i][2];
}
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] + h[i + 1][j]);
}
}
}
int ans = max({dp[n][0], dp[n][1], dp[n][2]});
cout << ans << endl;
} | #include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <stack>
#include <vector>
#define INFTY 10000000000
using namespace std;
int main() {
int n;
cin >> n;
int h[110000][3];
long long dp[110000][3] = {0};
for (int i = 1; i <= n; i++) {
cin >> h[i][0] >> h[i][1] >> h[i][2];
}
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] + h[i + 1][j]);
}
}
}
int ans = max({dp[n][0], dp[n][1], dp[n][2]});
cout << ans << endl;
}
| [
"variable_declaration.remove",
"expression.operation.binary.remove"
] | 964,022 | 964,023 | u591914971 | cpp |
p03162 | #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int arrA[n], arrB[n], arrC[n];
int dpA[n], dpB[n], dpC[n];
for (int i = 0; i < n; i++) {
cin >> arrA[i] >> arrB[i] >> arrC[i];
}
dpA[0] = arrA[0];
dpB[0] = arrB[0];
dpC[0] = arrC[0];
for (int i = 1; i < n; i++) {
dpA[i] = max(dpB[i - 1], dpC[i - 1]) + arrA[i];
dpB[i] = max(dpA[i - 1], dpC[i - 1]) + arrB[i];
dpC[i] = max(dpA[i - 1], dpB[i - 1]) + arrB[i];
}
cout << max(dpA[n - 1], max(dpB[n - 1], dpC[n - 1]));
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int arrA[n], arrB[n], arrC[n];
int dpA[n], dpB[n], dpC[n];
for (int i = 0; i < n; i++) {
cin >> arrA[i] >> arrB[i] >> arrC[i];
}
dpA[0] = arrA[0];
dpB[0] = arrB[0];
dpC[0] = arrC[0];
for (int i = 1; i < n; i++) {
dpA[i] = max(dpB[i - 1], dpC[i - 1]) + arrA[i];
dpB[i] = max(dpA[i - 1], dpC[i - 1]) + arrB[i];
dpC[i] = max(dpA[i - 1], dpB[i - 1]) + arrC[i];
}
cout << max(dpA[n - 1], max(dpB[n - 1], dpC[n - 1]));
return 0;
} | [
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 964,031 | 964,032 | u592913746 | cpp |
p03162 | #include <bits/stdc++.h>
#define ll long long
#define FAST_IO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define mod 1000000007
#define f(i, n) for (int i = 0; i < n; i++)
#define INF 1e9 + 5
#define LINF 1e18L + 5;
#define pb push_back
#define mk make_pair
using namespace std;
/************************BELIAL**********DEVIL*********BELIAL***********DEVIL*************************/
int main() {
int n;
cin >> n;
// vector<int> arr(n);
vector<int> dp(3, 0); // maintain ans of prev state
for (int days = 0; days < n; days++) {
vector<int> c(3); // for a,b,c
vector<int> new_dp(3, 0);
for (int i = 0; i < 3; i++)
cin >> c[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
if (i != j) {
new_dp[j] = max(new_dp[j], dp[i] + c[j]); // ans of cur state
}
}
}
dp = new_dp;
}
cout << max(max(dp[0], dp[1]), dp[2]);
} | #include <bits/stdc++.h>
#define ll long long
#define FAST_IO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define mod 1000000007
#define f(i, n) for (int i = 0; i < n; i++)
#define INF 1e9 + 5
#define LINF 1e18L + 5;
#define pb push_back
#define mk make_pair
using namespace std;
/************************BELIAL**********DEVIL*********BELIAL***********DEVIL*************************/
int main() {
int n;
cin >> n;
// vector<int> arr(n);
vector<int> dp(3, 0); // maintain ans of prev state
for (int days = 0; days < n; days++) {
vector<int> c(3); // for a,b,c
vector<int> new_dp(3, 0); // ans of cur state
for (int i = 0; i < 3; i++)
cin >> c[i];
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]); // ans of cur state
}
}
}
dp = new_dp;
}
cout << max(max(dp[0], dp[1]), dp[2]);
} | [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 964,033 | 964,034 | u703899606 | cpp |
p03162 | #include <bits/stdc++.h>
#define ll long long
#define FAST_IO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define mod 1000000007
#define f(i, n) for (int i = 0; i < n; i++)
#define INF 1e9 + 5
#define LINF 1e18L + 5;
#define pb push_back
#define mk make_pair
using namespace std;
/************************BELIAL**********DEVIL*********BELIAL***********DEVIL*************************/
int main() {
int n;
cin >> n;
// vector<int> arr(n);
vector<int> dp(3, 0); // maintain ans of prev state
for (int days = 0; days < n; days++) {
vector<int> c(3); // for a,b,c
vector<int> new_dp(3, 0);
for (int i = 0; i < 3; i++)
cin >> c[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
if (i != j) {
new_dp[j] = max(new_dp[j], dp[i] + c[j]); // ans of cur state
}
}
}
dp = new_dp;
}
cout << max(max(dp[0], dp[1]), dp[2]);
} | #include <bits/stdc++.h>
#define ll long long
#define FAST_IO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define mod 1000000007
#define f(i, n) for (int i = 0; i < n; i++)
#define INF 1e9 + 5
#define LINF 1e18L + 5;
#define pb push_back
#define mk make_pair
using namespace std;
/************************BELIAL**********DEVIL*********BELIAL***********DEVIL*************************/
int main() {
int n;
cin >> n;
// vector<int> arr(n);
vector<int> dp(3, 0); // maintain ans of prev state
for (int days = 0; days < n; days++) {
vector<int> c(3); // for a,b,c
vector<int> new_dp(3, 0);
for (int i = 0; i < 3; i++)
cin >> c[i];
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]); // ans of cur state
}
}
}
dp = new_dp;
}
cout << max(max(dp[0], dp[1]), dp[2]);
} | [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 964,033 | 964,035 | u703899606 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<vector<int>> a(n, vector<int>(3)), dp(n + 1, vector<int>(3));
for (int i = 0; i < n; i++)
for (int j = 0; j < 2; j++)
cin >> a.at(i).at(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.at(i + 1).at(j) =
max(dp.at(i + 1).at(j), dp.at(i).at(k) + a.at(i).at(j));
}
}
}
cout << *max_element(dp.at(n).begin(), dp.at(n).end()) << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<vector<int>> a(n, vector<int>(3)), dp(n + 1, vector<int>(3));
for (int i = 0; i < n; i++)
for (int j = 0; j < 3; j++)
cin >> a.at(i).at(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.at(i + 1).at(j) =
max(dp.at(i + 1).at(j), dp.at(i).at(k) + a.at(i).at(j));
}
}
}
cout << *max_element(dp.at(n).begin(), dp.at(n).end()) << endl;
}
| [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 964,036 | 964,037 | u697658632 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, j, k, h;
cin >> n;
vector<int> dp(3);
vector<int> c(3);
int i;
for (i = 0; i < n; i++) {
vector<int> new_dp(3, 0);
for (j = 0; j < 3; j++)
cin >> c[j];
for (k = 0; k < 3; k++)
for (h = 0; h < 3; h++)
if (h != k)
new_dp[h] = max(new_dp[h], new_dp[k] + c[h]);
dp = new_dp;
}
cout << max(dp[0], max(dp[1], dp[2])) << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, j, k, h;
cin >> n;
vector<int> dp(3);
vector<int> c(3);
int i;
for (i = 0; i < n; i++) {
vector<int> new_dp(3, 0);
for (j = 0; j < 3; j++)
cin >> c[j];
for (k = 0; k < 3; k++)
for (h = 0; h < 3; h++)
if (h != k)
new_dp[h] = max(new_dp[h], dp[k] + c[h]);
dp = new_dp;
}
cout << max(dp[0], max(dp[1], dp[2])) << endl;
} | [
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 964,040 | 964,041 | u420971902 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int maxn = 100005;
int a[maxn], b[maxn], c[maxn], dp[maxn][3];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i] >> b[i] >> c[i];
dp[0][0] = a[1], dp[0][1] = b[1], dp[0][2] = c[1];
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][0], dp[i - 1][1]) + c[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;
typedef long long ll;
typedef pair<int, int> pii;
const int maxn = 100005;
int a[maxn], b[maxn], c[maxn], dp[maxn][3];
int main() {
int n;
cin >> n;
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], 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][0], dp[i - 1][1]) + c[i];
}
cout << max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2])) << endl;
return 0;
}
| [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change"
] | 964,052 | 964,053 | u943208163 | cpp |
p03162 | #include <algorithm>
#include <cmath>
#include <cstring>
#include <fstream>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
const int N = 10000005;
long long a[N], b[N], dp[N][4], c[N], n, k;
long long solve(int i, int cant) {
if (dp[i][cant] != -1)
return dp[i][cant];
if (i == n)
return 0;
if (cant == 0) {
long long h = max(solve(i + 1, 3) + a[i], solve(i + 1, 1) + b[i]);
dp[i][cant] = max(h, solve(i + 1, 2) + c[i]);
} else if (cant == 3)
dp[i][cant] = max(solve(i + 1, 1) + b[i], solve(i + 1, 2) + c[i]);
else if (cant == 1)
dp[i][cant] = max(solve(i + 1, 0) + a[i], solve(i + 1, 2) + c[i]);
else
dp[i][cant] = max(solve(i + 1, 0) + a[i], solve(i + 1, 1) + b[i]);
return dp[i][cant];
}
int main() {
#ifdef MANSOUR
freopen("input.txt", "r", stdin);
#endif
cin >> n;
for (int i = 0; i < N; ++i) {
for (int j = 0; j < 4; ++j) {
dp[i][j] = -1;
}
}
for (int i = 0; i < n; i++)
cin >> a[i] >> b[i] >> c[i];
cout << solve(0, 0);
} | #include <algorithm>
#include <cmath>
#include <cstring>
#include <fstream>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
const int N = 1000005;
long long a[N], b[N], dp[N][4], c[N], n, k;
long long solve(int i, int cant) {
if (dp[i][cant] != -1)
return dp[i][cant];
if (i == n)
return 0;
if (cant == 0) {
long long h = max(solve(i + 1, 3) + a[i], solve(i + 1, 1) + b[i]);
dp[i][cant] = max(h, solve(i + 1, 2) + c[i]);
} else if (cant == 3)
dp[i][cant] = max(solve(i + 1, 1) + b[i], solve(i + 1, 2) + c[i]);
else if (cant == 1)
dp[i][cant] = max(solve(i + 1, 3) + a[i], solve(i + 1, 2) + c[i]);
else
dp[i][cant] = max(solve(i + 1, 3) + a[i], solve(i + 1, 1) + b[i]);
return dp[i][cant];
}
int main() {
#ifdef MANSOUR
freopen("input.txt", "r", stdin);
#endif
cin >> n;
for (int i = 0; i < N; ++i) {
for (int j = 0; j < 4; ++j) {
dp[i][j] = -1;
}
}
for (int i = 0; i < n; i++)
cin >> a[i] >> b[i] >> c[i];
cout << solve(0, 0);
} | [
"literal.number.change",
"variable_declaration.value.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 964,054 | 964,055 | u605872309 | cpp |
p03162 | #include <algorithm>
#include <cmath>
#include <cstring>
#include <fstream>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
const int N = 1000005;
long long a[N], b[N], dp[N][4], c[N], n, k;
long long solve(int i, int cant) {
if (dp[i][cant] != -1)
return dp[i][cant];
if (i == n)
return 0;
if (cant == 0) {
long long h = max(solve(i + 1, 3) + a[i], solve(i + 1, 1) + b[i]);
dp[i][cant] = max(h, solve(i + 1, 2) + c[i]);
} else if (cant == 3)
dp[i][cant] = max(solve(i + 1, 1) + b[i], solve(i + 1, 2) + c[i]);
else if (cant == 1)
dp[i][cant] = max(solve(i + 1, 0) + a[i], solve(i + 1, 2) + c[i]);
else
dp[i][cant] = max(solve(i + 1, 0) + a[i], solve(i + 1, 1) + b[i]);
return dp[i][cant];
}
int main() {
#ifdef MANSOUR
freopen("input.txt", "r", stdin);
#endif
cin >> n;
for (int i = 0; i < N; ++i) {
for (int j = 0; j < 4; ++j) {
dp[i][j] = -1;
}
}
for (int i = 0; i < n; i++)
cin >> a[i] >> b[i] >> c[i];
cout << solve(0, 0);
} | #include <algorithm>
#include <cmath>
#include <cstring>
#include <fstream>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
const int N = 1000005;
long long a[N], b[N], dp[N][4], c[N], n, k;
long long solve(int i, int cant) {
if (dp[i][cant] != -1)
return dp[i][cant];
if (i == n)
return 0;
if (cant == 0) {
long long h = max(solve(i + 1, 3) + a[i], solve(i + 1, 1) + b[i]);
dp[i][cant] = max(h, solve(i + 1, 2) + c[i]);
} else if (cant == 3)
dp[i][cant] = max(solve(i + 1, 1) + b[i], solve(i + 1, 2) + c[i]);
else if (cant == 1)
dp[i][cant] = max(solve(i + 1, 3) + a[i], solve(i + 1, 2) + c[i]);
else
dp[i][cant] = max(solve(i + 1, 3) + a[i], solve(i + 1, 1) + b[i]);
return dp[i][cant];
}
int main() {
#ifdef MANSOUR
freopen("input.txt", "r", stdin);
#endif
cin >> n;
for (int i = 0; i < N; ++i) {
for (int j = 0; j < 4; ++j) {
dp[i][j] = -1;
}
}
for (int i = 0; i < n; i++)
cin >> a[i] >> b[i] >> c[i];
cout << solve(0, 0);
} | [
"literal.number.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 964,056 | 964,055 | u605872309 | cpp |
p03162 | #include <algorithm>
#include <cmath>
#include <cstring>
#include <fstream>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
const int N = 100005;
long long a[N], b[N], dp[N][4], c[N], n, k;
long long solve(int i, int cant) {
if (dp[i][cant] != -1)
return dp[i][cant];
if (i == n)
return 0;
if (cant == 0) {
long long h = max(solve(i + 1, 3) + a[i], solve(i + 1, 1) + b[i]);
dp[i][cant] = max(h, solve(i + 1, 2) + c[i]);
} else if (cant == 3)
dp[i][cant] = max(solve(i + 1, 1) + b[i], solve(i + 1, 2) + c[i]);
else if (cant == 1)
dp[i][cant] = max(solve(i + 1, 0) + a[i], solve(i + 1, 2) + c[i]);
else
dp[i][cant] = max(solve(i + 1, 0) + a[i], solve(i + 1, 1) + b[i]);
return dp[i][cant];
}
int main() {
#ifdef MANSOUR
freopen("input.txt", "r", stdin);
#endif
cin >> n;
for (int i = 0; i < N; ++i) {
for (int j = 0; j < 4; ++j) {
dp[i][j] = -1;
}
}
for (int i = 0; i < n; i++)
cin >> a[i] >> b[i] >> c[i];
cout << solve(0, 0);
} | #include <algorithm>
#include <cmath>
#include <cstring>
#include <fstream>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
const int N = 1000005;
long long a[N], b[N], dp[N][4], c[N], n, k;
long long solve(int i, int cant) {
if (dp[i][cant] != -1)
return dp[i][cant];
if (i == n)
return 0;
if (cant == 0) {
long long h = max(solve(i + 1, 3) + a[i], solve(i + 1, 1) + b[i]);
dp[i][cant] = max(h, solve(i + 1, 2) + c[i]);
} else if (cant == 3)
dp[i][cant] = max(solve(i + 1, 1) + b[i], solve(i + 1, 2) + c[i]);
else if (cant == 1)
dp[i][cant] = max(solve(i + 1, 3) + a[i], solve(i + 1, 2) + c[i]);
else
dp[i][cant] = max(solve(i + 1, 3) + a[i], solve(i + 1, 1) + b[i]);
return dp[i][cant];
}
int main() {
#ifdef MANSOUR
freopen("input.txt", "r", stdin);
#endif
cin >> n;
for (int i = 0; i < N; ++i) {
for (int j = 0; j < 4; ++j) {
dp[i][j] = -1;
}
}
for (int i = 0; i < n; i++)
cin >> a[i] >> b[i] >> c[i];
cout << solve(0, 0);
} | [
"literal.number.change",
"variable_declaration.value.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 964,057 | 964,055 | u605872309 | cpp |
p03162 | #include "bits/stdc++.h"
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define all(v, a, b) v.begin(a), v.end(b)
#define in cin >>
#define out cout <<
#define end << endl
#define INF 100000000000
int main() {
int N;
in N;
vector<vector<int>> abc(N, vector<int>(3));
rep(i, N) { in abc.at(i).at(0) >> abc.at(i).at(1) >> abc.at(i).at(2); }
vector<vector<int>> ans(N, vector<int>(3));
rep(i, N - 1) {
rep(j, 3) {
rep(x, 3) {
if (j == x) {
continue;
}
ans.at(i + 1).at(x) =
max(ans.at(i).at(j) + abc.at(i).at(x), ans.at(i + 1).at(x));
}
}
}
int l = 0;
rep(i, 3) { l = max(l, ans.at(N - 1).at(i)); }
out l end;
}
| #include "bits/stdc++.h"
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define all(v, a, b) v.begin(a), v.end(b)
#define in cin >>
#define out cout <<
#define end << endl
#define INF 100000000000
int main() {
int N;
in N;
vector<vector<int>> abc(N, vector<int>(3));
rep(i, N) { in abc.at(i).at(0) >> abc.at(i).at(1) >> abc.at(i).at(2); }
vector<vector<int>> ans(N + 1, vector<int>(3));
rep(i, N) {
rep(j, 3) {
rep(x, 3) {
if (j == x) {
continue;
}
ans.at(i + 1).at(x) =
max(ans.at(i).at(j) + abc.at(i).at(x), ans.at(i + 1).at(x));
}
}
}
int l = 0;
rep(i, 3) { l = max(l, ans.at(N).at(i)); }
out l end;
}
| [
"expression.operation.binary.remove"
] | 964,058 | 964,059 | u550560757 | cpp |
p03162 | #include "bits/stdc++.h"
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define all(v, a, b) v.begin(a), v.end(b)
#define in cin >>
#define out cout <<
#define end << endl
#define INF 100000000000
int main() {
int N;
in N;
vector<vector<int>> abc(N, vector<int>(3));
rep(i, N) { in abc.at(i).at(0) >> abc.at(i).at(1) >> abc.at(i).at(2); }
vector<vector<int>> ans(N, vector<int>(3));
rep(i, N) {
rep(j, 3) {
rep(x, 3) {
if (j == x) {
continue;
}
ans.at(i + 1).at(x) =
max(ans.at(i).at(j) + abc.at(i).at(x), ans.at(i + 1).at(x));
}
}
}
int l = 0;
rep(i, 3) { l = max(l, ans.at(N - 1).at(i)); }
out l end;
}
| #include "bits/stdc++.h"
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define all(v, a, b) v.begin(a), v.end(b)
#define in cin >>
#define out cout <<
#define end << endl
#define INF 100000000000
int main() {
int N;
in N;
vector<vector<int>> abc(N, vector<int>(3));
rep(i, N) { in abc.at(i).at(0) >> abc.at(i).at(1) >> abc.at(i).at(2); }
vector<vector<int>> ans(N + 1, vector<int>(3));
rep(i, N) {
rep(j, 3) {
rep(x, 3) {
if (j == x) {
continue;
}
ans.at(i + 1).at(x) =
max(ans.at(i).at(j) + abc.at(i).at(x), ans.at(i + 1).at(x));
}
}
}
int l = 0;
rep(i, 3) { l = max(l, ans.at(N).at(i)); }
out l end;
}
| [
"expression.operation.binary.remove"
] | 964,060 | 964,059 | u550560757 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> dp(3);
for (int i = 0; i < n; i++) {
vector<int> new_dp(3);
vector<int> c(3);
for (int i = 0; i < n; i++)
scanf("%d", &c[i]);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i != j) {
// cout << dp[i] << endl;
new_dp[j] = max(new_dp[j], dp[i] + c[j]);
}
}
}
dp = new_dp;
}
cout << max({dp[0], dp[1], dp[2]}) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> dp(3);
for (int days = 0; days < n; days++) {
vector<int> new_dp(3);
vector<int> c(3);
for (int i = 0; i < 3; i++)
scanf("%d", &c[i]);
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (i != j) {
// cout << dp[i] << endl;
new_dp[j] = max(new_dp[j], dp[i] + c[j]);
}
}
}
dp = new_dp;
}
cout << max({dp[0], dp[1], dp[2]}) << endl;
return 0;
}
| [
"variable_declaration.name.change",
"identifier.change",
"control_flow.loop.for.initializer.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"identifier.replace.remove",
"literal.replace.add"
] | 964,061 | 964,062 | u568117906 | cpp |
p03162 | #include <iostream>
using namespace std;
long long int l[100000][3];
int n;
int naj = -1;
long long int dp[100000][3];
int main(void) {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int a, b, c;
cin >> a >> b >> c;
l[i][0] = a;
l[i][1] = b;
l[i][0] = c;
}
dp[0][0] = l[0][0];
dp[0][1] = l[0][1];
dp[0][2] = l[0][2];
for (int i = 1; i < n; i++) {
dp[i][0] = max(dp[i - 1][1] + l[i][0], dp[i - 1][2] + l[i][0]);
dp[i][1] = max(dp[i - 1][0] + l[i][1], dp[i - 1][2] + l[i][1]);
dp[i][2] = max(dp[i - 1][1] + l[i][2], dp[i - 1][0] + l[i][2]);
}
cout << max(max(dp[n - 1][0], dp[n - 1][1]), dp[n - 1][2]);
return 0;
}
| #include <iostream>
using namespace std;
long long int l[100000][3];
int n;
int naj = -1;
long long int dp[100000][3];
int main(void) {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int a, b, c;
cin >> a >> b >> c;
l[i][0] = a;
l[i][1] = b;
l[i][2] = c;
}
dp[0][0] = l[0][0];
dp[0][1] = l[0][1];
dp[0][2] = l[0][2];
for (int i = 1; i < n; i++) {
dp[i][0] = max(dp[i - 1][1] + l[i][0], dp[i - 1][2] + l[i][0]);
dp[i][1] = max(dp[i - 1][0] + l[i][1], dp[i - 1][2] + l[i][1]);
dp[i][2] = max(dp[i - 1][1] + l[i][2], dp[i - 1][0] + l[i][2]);
}
cout << max(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"
] | 964,063 | 964,064 | u830900349 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
int n;
int data[4][100005];
int dp[4][100005];
int ans;
cin >> n;
for (int i = 1; i <= n; i++)
cin >> data[1][i] >> data[2][i] >> data[3][i];
dp[1][1] = data[1][1];
dp[2][1] = data[2][1];
dp[3][1] = data[3][1];
for (int i = 2; i <= n; i++) {
dp[1][i] = max(dp[2][i - 1], dp[3][i - 1]) + data[1][i - 1];
dp[2][i] = max(dp[1][i - 1], dp[3][i - 1]) + data[2][i - 1];
dp[3][i] = max(dp[2][i - 1], dp[1][i - 1]) + data[3][i - 1];
}
ans = max(dp[1][n], dp[2][n]);
cout << max(ans, dp[3][n]) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
int n;
int data[4][100005];
int dp[4][100005];
int ans;
cin >> n;
for (int i = 1; i <= n; i++)
cin >> data[1][i] >> data[2][i] >> data[3][i];
dp[1][1] = data[1][1];
dp[2][1] = data[2][1];
dp[3][1] = data[3][1];
for (int i = 2; i <= n; i++) {
dp[1][i] = max(dp[2][i - 1], dp[3][i - 1]) + data[1][i];
dp[2][i] = max(dp[1][i - 1], dp[3][i - 1]) + data[2][i];
dp[3][i] = max(dp[2][i - 1], dp[1][i - 1]) + data[3][i];
}
ans = max(dp[1][n], dp[2][n]);
cout << max(ans, dp[3][n]) << endl;
return 0;
}
| [
"expression.operation.binary.remove"
] | 964,065 | 964,066 | u935028161 | cpp |
p03162 | #include <iostream>
using namespace std;
long n, a[10000][10000], f[10000][10000];
int main() {
cin >> n;
for (long i = 1; i <= n; i++) {
for (long j = 1; j <= 3; j++)
cin >> a[i][j];
}
f[0][1] = 0;
f[0][2] = 0;
f[0][3] = 0;
for (long i = 1; i <= n; i++) {
for (long j = 1; j <= 3; j++) {
if (j == 1) {
f[i][j] = max(a[i][j] + f[i - 1][j + 1], a[i][j] + f[i - 1][j + 2]);
}
if (j == 2) {
f[i][j] = max(a[i][j] + f[i - 1][j - 1], a[i][j] + f[i - 1][j + 1]);
}
if (j == 3) {
f[i][j] = max(a[i][j] + f[i - 1][j - 1], a[i][j] + f[i - 1][j - 2]);
}
}
}
cout << max(f[n][1], max(f[n][2], f[n][3]));
return 0;
}
| #include <iostream>
using namespace std;
long n, a[100005][4], f[100005][4];
int main() {
cin >> n;
for (long i = 1; i <= n; i++) {
for (long j = 1; j <= 3; j++)
cin >> a[i][j];
}
f[0][1] = 0;
f[0][2] = 0;
f[0][3] = 0;
for (long i = 1; i <= n; i++) {
for (long j = 1; j <= 3; j++) {
if (j == 1) {
f[i][j] = max(a[i][j] + f[i - 1][j + 1], a[i][j] + f[i - 1][j + 2]);
}
if (j == 2) {
f[i][j] = max(a[i][j] + f[i - 1][j - 1], a[i][j] + f[i - 1][j + 1]);
}
if (j == 3) {
f[i][j] = max(a[i][j] + f[i - 1][j - 1], a[i][j] + f[i - 1][j - 2]);
}
}
}
cout << max(f[n][1], max(f[n][2], f[n][3]));
return 0;
}
| [
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 964,069 | 964,070 | u777021364 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repd(i, a, b) for (int i = (a); i < (b); i++)
#define INF LLONG_MAX
typedef long long ll;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
int main(void) {
ll N, ans = 0;
cin >> N;
ll v[N][3];
ll dp[N + 1][3];
rep(i, N) rep(j, N) cin >> v[i][j];
rep(i, N + 1) rep(j, 3) dp[i][j] = 0;
rep(i, N) {
rep(j, 3) {
rep(k, 3) {
if (j == k)
continue;
chmax(dp[i + 1][k], dp[i][j] + v[i][k]);
}
}
}
rep(i, 3) chmax(ans, dp[N][i]);
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repd(i, a, b) for (int i = (a); i < (b); i++)
#define INF LLONG_MAX
typedef long long ll;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
int main(void) {
ll N, ans = 0;
cin >> N;
ll v[N][3];
ll dp[N + 1][3];
rep(i, N) rep(j, 3) cin >> v[i][j];
rep(i, N + 1) rep(j, 3) dp[i][j] = 0;
rep(i, N) {
rep(j, 3) {
rep(k, 3) {
if (j == k)
continue;
chmax(dp[i + 1][k], dp[i][j] + v[i][k]);
}
}
}
rep(i, 3) chmax(ans, dp[N][i]);
cout << ans << endl;
}
| [
"identifier.replace.remove",
"literal.replace.add",
"call.arguments.change"
] | 964,073 | 964,074 | u854690176 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.