problem_id stringlengths 6 6 | buggy_code stringlengths 8 526k ⌀ | fixed_code stringlengths 12 526k ⌀ | labels listlengths 0 15 ⌀ | buggy_submission_id int64 1 1.54M ⌀ | fixed_submission_id int64 2 1.54M ⌀ | user_id stringlengths 10 10 ⌀ | language stringclasses 9
values |
|---|---|---|---|---|---|---|---|
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> a(N);
vector<int> b(N);
vector<int> c(N);
for (int i = 0; i < N; i++) {
int A, B, C;
cin >> A >> B >> C;
a.at(i) = A;
b.at(i) = B;
c.at(i) = C;
}
vector<vector<int>> dp(N + 1, vector<int>(3, 0));
for (int i = 0; i <= N; i++) {
dp[i][0] = a.at(i - 1) + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = b.at(i - 1) + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = c.at(i - 1) + max(dp[i - 1][0], dp[i - 1][1]);
}
int ans = max(dp[N][0], max(dp[N][1], dp[N][2]));
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> a(N);
vector<int> b(N);
vector<int> c(N);
for (int i = 0; i < N; i++) {
int A, B, C;
cin >> A >> B >> C;
a.at(i) = A;
b.at(i) = B;
c.at(i) = C;
}
vector<vector<int>> dp(N + 1, vector<int>(3, 0));
for (int i = 1; i <= N; i++) {
dp[i][0] = a.at(i - 1) + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = b.at(i - 1) + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = c.at(i - 1) + max(dp[i - 1][0], dp[i - 1][1]);
}
int ans = max(dp[N][0], max(dp[N][1], dp[N][2]));
cout << ans << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 963,139 | 963,140 | u101018317 | cpp |
p03162 | #include <algorithm>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
vector<vector<int>> dp(n, vector<int>(3, __INT32_MAX__));
for (int i = 0; i < n; i++) {
int a, b, c;
cin >> a >> b >> c;
if (i == 0) {
dp[i][0] = a;
dp[i][1] = b;
dp[i][2] = c;
} else {
dp[i][0] = max(dp[i - 1][1] + b, dp[i - 1][2] + c);
dp[i][1] = max(dp[i - 1][2] + c, dp[i - 1][0] + a);
dp[i][2] = max(dp[i - 1][0] + a, dp[i - 1][1] + b);
}
}
cout << max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2])) << endl;
return 0;
} | #include <algorithm>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
vector<vector<int>> dp(n, vector<int>(3, __INT32_MAX__));
for (int i = 0; i < n; i++) {
int a, b, c;
cin >> a >> b >> c;
if (i == 0) {
dp[i][0] = a;
dp[i][1] = b;
dp[i][2] = c;
} else {
dp[i][0] = max(dp[i - 1][1] + a, dp[i - 1][2] + a);
dp[i][1] = max(dp[i - 1][2] + b, dp[i - 1][0] + b);
dp[i][2] = max(dp[i - 1][0] + c, dp[i - 1][1] + c);
}
}
cout << max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2])) << endl;
return 0;
} | [
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 963,149 | 963,150 | u530350853 | cpp |
p03162 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <vector>
#define fi first
#define se second
#define pb push_back
#define pii pair<int, int>
#define ll long long
#define pll pair<ll, ll>
#define rep(i, from, to) for (int i = from; i < to; i++)
#define repd(i, from, till) for (int i = from; i >= till; i--)
#define waste \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL)
#define inf 1e9 + 1
#define mod 1e9 + 7
#define inf1 1e18 + 1
#define pie 3.14159265358979323846
#define N 100005
using namespace std;
void solve() {
int n;
cin >> n;
int a[n][3];
rep(i, 0, n) rep(j, 0, 3) cin >> a[i][j];
int t1 = a[0][0], t2 = a[0][1], t3 = a[0][2];
int maxa[3];
maxa[0] = t1;
maxa[1] = t2;
maxa[2] = t3;
rep(i, 1, n) {
// cout<<t1<<" "<<t2<<" "<<t3<<" "<<endl;
maxa[0] = max(t2 + a[i][0], t3 + a[i][0]);
maxa[1] = max(t1 + a[i][1], t3 + a[i][1]);
maxa[2] = max(t2 + a[i][2], t1 + a[i][2]);
t1 = maxa[0];
t2 = maxa[1];
t3 = maxa[2];
}
cout << max(max(maxa[0], maxa[1]), maxa[2]) << endl;
}
int main() {
waste;
int t;
cin >> t;
// t=1;
while (t--) {
solve();
}
}
| #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <vector>
#define fi first
#define se second
#define pb push_back
#define pii pair<int, int>
#define ll long long
#define pll pair<ll, ll>
#define rep(i, from, to) for (int i = from; i < to; i++)
#define repd(i, from, till) for (int i = from; i >= till; i--)
#define waste \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL)
#define inf 1e9 + 1
#define mod 1e9 + 7
#define inf1 1e18 + 1
#define pie 3.14159265358979323846
#define N 100005
using namespace std;
void solve() {
int n;
cin >> n;
int a[n][3];
rep(i, 0, n) rep(j, 0, 3) cin >> a[i][j];
int t1 = a[0][0], t2 = a[0][1], t3 = a[0][2];
int maxa[3];
maxa[0] = t1;
maxa[1] = t2;
maxa[2] = t3;
rep(i, 1, n) {
// cout<<t1<<" "<<t2<<" "<<t3<<" "<<endl;
maxa[0] = max(t2 + a[i][0], t3 + a[i][0]);
maxa[1] = max(t1 + a[i][1], t3 + a[i][1]);
maxa[2] = max(t2 + a[i][2], t1 + a[i][2]);
t1 = maxa[0];
t2 = maxa[1];
t3 = maxa[2];
}
cout << max(max(maxa[0], maxa[1]), maxa[2]) << endl;
}
int main() {
waste;
int t;
// cin>>t;
t = 1;
while (t--) {
solve();
}
}
| [
"expression.operation.binary.remove",
"assignment.change"
] | 963,151 | 963,152 | u352350187 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
struct option {
int x, y, z;
};
int vacation(option *arr, int n) {
int dp[n][3];
dp[0][0] = arr[0].x;
dp[0][1] = arr[0].y;
dp[0][2] = arr[0].z;
for (int i = 1; i < n; i++) {
dp[i][0] = arr[i].x + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = arr[i].y + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = arr[i].z + max(dp[i - 1][1], dp[i - 1][2]);
}
return max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2]));
}
int main() {
int n;
cin >> n;
option *arr = new option[n];
for (int i = 0; i < n; i++) {
cin >> arr[i].x >> arr[i].y >> arr[i].z;
}
int ans = vacation(arr, n);
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
struct option {
int x, y, z;
};
int vacation(option *arr, int n) {
int dp[n][3];
dp[0][0] = arr[0].x;
dp[0][1] = arr[0].y;
dp[0][2] = arr[0].z;
for (int i = 1; i < n; i++) {
dp[i][0] = arr[i].x + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = arr[i].y + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = arr[i].z + max(dp[i - 1][1], dp[i - 1][0]);
}
return max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2]));
}
int main() {
int n;
cin >> n;
option *arr = new option[n];
for (int i = 0; i < n; i++) {
cin >> arr[i].x >> arr[i].y >> arr[i].z;
}
int ans = vacation(arr, n);
cout << ans << endl;
}
| [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 963,162 | 963,163 | u133683370 | cpp |
p03162 | /*
╔═══╦═══╦═══╗
║╔═╗║╔══╩╗╔╗║
║║░║║╚══╗║║║║
║║░║║╔══╝║║║║
║╚═╝║╚══╦╝╚╝║
╚══╗╠═══╩═══╝
░░░╚╝░░░░░░░░
*/
#include <bits/stdc++.h>
#define ll long long
#define MOD 1000000007
#define MAX 1e9
#define MIN -1e9
#define PI acos(-1.0)
#define vi vector<int>
#define vii vector<vi>
#define vll vector<ll>
#define mid(s, e) (s + (e - s) / 2)
#define clz(n) __builtin_clzll(n))
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V> void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T> void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x)
cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V> void _print(T t, V... v) {
__print(t);
if (sizeof...(v))
cerr << ", ";
_print(v...);
}
template <typename T> void printVec(const T &v, char sep = ' ') {
for (auto &i : v)
cout << i << sep;
}
template <typename T> void printVecPair(const T &v, char sep = ' ') {
for (auto &i : v)
cout << i.first << " " << i.second << sep;
}
#ifndef ONLINE_JUDGE
#define debug(x...) \
cerr << "[" << #x << "] = ["; \
_print(x)
#else
#define debug(x...)
#endif
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vii dp(2, vi(3));
for (int i = 0; i < n; i++) {
int c[3];
for (int j = 0; j < 3; cin >> c[j++])
;
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
if (j != k) {
dp[i & 1][j] = max(dp[(i + 1) & 1][k] + c[j], dp[(i + 1) & 1][j]);
}
}
}
debug(dp);
}
cout << max({dp[(n - 1) & 1][0], dp[(n - 1) & 1][1], dp[(n - 1) & 1][2]});
return 0;
}
| /*
╔═══╦═══╦═══╗
║╔═╗║╔══╩╗╔╗║
║║░║║╚══╗║║║║
║║░║║╔══╝║║║║
║╚═╝║╚══╦╝╚╝║
╚══╗╠═══╩═══╝
░░░╚╝░░░░░░░░
*/
#include <bits/stdc++.h>
#define ll long long
#define MOD 1000000007
#define MAX 1e9
#define MIN -1e9
#define PI acos(-1.0)
#define vi vector<int>
#define vii vector<vi>
#define vll vector<ll>
#define mid(s, e) (s + (e - s) / 2)
#define clz(n) __builtin_clzll(n))
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V> void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T> void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x)
cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V> void _print(T t, V... v) {
__print(t);
if (sizeof...(v))
cerr << ", ";
_print(v...);
}
template <typename T> void printVec(const T &v, char sep = ' ') {
for (auto &i : v)
cout << i << sep;
}
template <typename T> void printVecPair(const T &v, char sep = ' ') {
for (auto &i : v)
cout << i.first << " " << i.second << sep;
}
#ifndef ONLINE_JUDGE
#define debug(x...) \
cerr << "[" << #x << "] = ["; \
_print(x)
#else
#define debug(x...)
#endif
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vii dp(2, vi(3));
for (int i = 0; i < n; i++) {
int c[3];
for (int j = 0; j < 3; cin >> c[j++])
;
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
if (j != k) {
dp[i & 1][j] = max(dp[(i + 1) & 1][k] + c[j], dp[i & 1][j]);
}
}
}
debug(dp);
}
cout << max({dp[(n - 1) & 1][0], dp[(n - 1) & 1][1], dp[(n - 1) & 1][2]});
return 0;
}
| [
"call.arguments.change"
] | 963,166 | 963,167 | u288568295 | cpp |
p03162 | #include <bits/stdc++.h>
#include <stdint.h>
using namespace std;
#define int long long
#define pb push_back
#define mod 1000000007
#define w(x) \
int x; \
cin >> x; \
while (x-- > 0)
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
void mysol() {
int n;
cin >> n;
int arr[n][n];
for (auto &i : arr)
for (auto &j : i)
cin >> j;
int dp[n + 1][n];
memset(dp, 0, sizeof(dp));
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
if (k == j)
continue;
dp[i + 1][j] = max(dp[i + 1][j], arr[i][j] + dp[i][k]);
}
}
}
int ans = 0;
for (int i = 0; i < n; i++)
ans = max(ans, dp[n][i]);
cout << ans;
}
int32_t main() {
fast();
// w(t)
{ mysol(); }
return 0;
}
| #include <bits/stdc++.h>
#include <stdint.h>
using namespace std;
#define int long long
#define pb push_back
#define mod 1000000007
#define w(x) \
int x; \
cin >> x; \
while (x-- > 0)
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
void mysol() {
int n;
cin >> n;
int arr[n][3];
for (auto &i : arr)
for (auto &j : i)
cin >> j;
int dp[n + 1][3];
memset(dp, 0, sizeof(dp));
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
if (k == j)
continue;
dp[i + 1][j] = max(dp[i + 1][j], arr[i][j] + dp[i][k]);
}
}
}
int ans = 0;
for (int i = 0; i < 3; i++)
ans = max(ans, dp[n][i]);
cout << ans;
}
int32_t main() {
fast();
// w(t)
{ mysol(); }
return 0;
}
| [
"identifier.replace.remove",
"literal.replace.add",
"variable_declaration.array_dimensions.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 963,172 | 963,173 | u464104383 | cpp |
p03162 | #include <algorithm>
#include <assert.h>
#include <cmath>
#include <cstring>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define lop(i, n) for (int i = 0; i < n; i++)
#define VI vector<int>
#define VLL vector<ll>
#define VPI vector<pair<int, int>>
#define VII vector<VI>
#define all(v) v.begin(), v.end()
#define SORT(v) sort(all(v))
#define ll long long
#define ull unsigned long long
#define scni(x) scanf("%d", &x)
#define scnll(x) scanf("%lld", &x)
#define scnd(x) scanf("%lf", &x)
#define prnti(x) printf("%d\n", x)
#define prntll(x) printf("%lld", x)
#define prntd(x) printf("%.9lf", x)
#define sz(x) x.size()
#define pp push_back
#define P pair<int, int>
#define mp make_pair
const double EPS = 1e-9;
const double PI = 3.14159265359;
// O( n * log(log(n)) )
vector<ll> primes;
void GeneratingPrimes(int top) {
vector<bool> p(top + 1, 1);
// vector<ll> primes;
p[0] = p[1] = 0;
for (int i = 2; i <= sqrt(top); i++) {
if (p[i]) {
for (int j = i * i; j <= top; j += i) {
p[j] = 0;
}
}
}
lop(i, top + 1) if (p[i]) primes.push_back(i);
// return primes;
}
ll gcd(ll a, ll b) { return (b == 0) ? a : gcd(b, a % b); }
ll lcm(ll a, ll b) { return (a * b) / gcd(a, b); }
void EXTgcd(ll a, ll b, ll &x0, ll &y0) {
if (b == 0) {
x0 = 1, y0 = 0;
return;
}
EXTgcd(b, a % b, x0, y0);
ll x1 = y0;
ll y1 = x0 - (a / b) * (y0);
y1 = y1;
x0 = x1;
y0 = y1;
}
long long power(long long n, long long p, ll mod) {
if (!p)
return 1;
long long ans = 1;
while (p > 1) {
if (p & 1)
ans = (ans * n) % mod;
n = (n * n) % mod;
p /= 2;
}
return (ans * n) % mod;
}
double dist(double a, double b, double x, double y) {
return sqrt(pow(a - x, 2) + pow(b - y, 2));
}
double dist3(double a, double b, double c, double x, double y, double z) {
return sqrt(pow(a - x, 2) + pow(b - y, 2) + pow(c - z, 2));
}
int xadd[9] = {1, -1, 0, 1, -1, 0, 1, -1, 0};
int yadd[9] = {1, -1, 0, -1, 0, 1, 0, 1, -1};
int xx[4] = {0, 1, 0, -1};
int yy[4] = {1, 0, -1, 0};
// string digits[]= {"1110111", "0010010", "1011101", "1011011", "0111010",
// "1101011", "1101111", "1010010", "1111111", "1111011"};
#define no \
{ cout << "NO\n"; }
#define yes \
{ cout << "YES\n"; }
#define _1 \
{ cout << "-1\n"; }
ll const N = 1e5 + 10;
ll const INF = 1e18;
ll const mod = 1000000007;
///////////////////////////////////////////////////////////////////
ll n, a[N][3], dp[N][3];
int main() {
cin >> n;
lop(i, n) { lop(j, 3) scnll(a[i][j]); }
lop(i, 3) dp[0][i] = a[0][i];
for (int i = 1; i < n; i++) {
lop(j, 3) {
lop(k, 3) if (k != j) dp[j][i] = max(dp[i][j], dp[i - 1][k] + a[i][j]);
}
}
ll ans = 0;
lop(i, 3) ans = max(ans, dp[n - 1][i]);
cout << ans;
return 0;
} | #include <algorithm>
#include <assert.h>
#include <cmath>
#include <cstring>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define lop(i, n) for (int i = 0; i < n; i++)
#define VI vector<int>
#define VLL vector<ll>
#define VPI vector<pair<int, int>>
#define VII vector<VI>
#define all(v) v.begin(), v.end()
#define SORT(v) sort(all(v))
#define ll long long
#define ull unsigned long long
#define scni(x) scanf("%d", &x)
#define scnll(x) scanf("%lld", &x)
#define scnd(x) scanf("%lf", &x)
#define prnti(x) printf("%d\n", x)
#define prntll(x) printf("%lld", x)
#define prntd(x) printf("%.9lf", x)
#define sz(x) x.size()
#define pp push_back
#define P pair<int, int>
#define mp make_pair
const double EPS = 1e-9;
const double PI = 3.14159265359;
// O( n * log(log(n)) )
vector<ll> primes;
void GeneratingPrimes(int top) {
vector<bool> p(top + 1, 1);
// vector<ll> primes;
p[0] = p[1] = 0;
for (int i = 2; i <= sqrt(top); i++) {
if (p[i]) {
for (int j = i * i; j <= top; j += i) {
p[j] = 0;
}
}
}
lop(i, top + 1) if (p[i]) primes.push_back(i);
// return primes;
}
ll gcd(ll a, ll b) { return (b == 0) ? a : gcd(b, a % b); }
ll lcm(ll a, ll b) { return (a * b) / gcd(a, b); }
void EXTgcd(ll a, ll b, ll &x0, ll &y0) {
if (b == 0) {
x0 = 1, y0 = 0;
return;
}
EXTgcd(b, a % b, x0, y0);
ll x1 = y0;
ll y1 = x0 - (a / b) * (y0);
y1 = y1;
x0 = x1;
y0 = y1;
}
long long power(long long n, long long p, ll mod) {
if (!p)
return 1;
long long ans = 1;
while (p > 1) {
if (p & 1)
ans = (ans * n) % mod;
n = (n * n) % mod;
p /= 2;
}
return (ans * n) % mod;
}
double dist(double a, double b, double x, double y) {
return sqrt(pow(a - x, 2) + pow(b - y, 2));
}
double dist3(double a, double b, double c, double x, double y, double z) {
return sqrt(pow(a - x, 2) + pow(b - y, 2) + pow(c - z, 2));
}
int xadd[9] = {1, -1, 0, 1, -1, 0, 1, -1, 0};
int yadd[9] = {1, -1, 0, -1, 0, 1, 0, 1, -1};
int xx[4] = {0, 1, 0, -1};
int yy[4] = {1, 0, -1, 0};
// string digits[]= {"1110111", "0010010", "1011101", "1011011", "0111010",
// "1101011", "1101111", "1010010", "1111111", "1111011"};
#define no \
{ cout << "NO\n"; }
#define yes \
{ cout << "YES\n"; }
#define _1 \
{ cout << "-1\n"; }
ll const N = 1e5 + 10;
ll const INF = 1e18;
ll const mod = 1000000007;
///////////////////////////////////////////////////////////////////
ll n, a[N][3], dp[N][3];
int main() {
cin >> n;
lop(i, n) { lop(j, 3) scnll(a[i][j]); }
lop(i, 3) dp[0][i] = a[0][i];
for (int i = 1; i < n; i++) {
lop(j, 3) {
lop(k, 3) if (k != j) dp[i][j] = max(dp[i][j], dp[i - 1][k] + a[i][j]);
}
}
ll ans = 0;
lop(i, 3) ans = max(ans, dp[n - 1][i]);
cout << ans;
return 0;
} | [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change"
] | 963,176 | 963,177 | u689853759 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int A[n];
int B[n];
int C[n];
for (int i = 0; i < n; i++) {
cin >> A[i] >> B[i] >> C[i];
}
int dp[n][3];
dp[0][0] = A[0];
dp[0][1] = C[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])) << "\n";
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int A[n];
int B[n];
int C[n];
for (int i = 0; i < n; i++) {
cin >> A[i] >> B[i] >> C[i];
}
int dp[n][3];
dp[0][0] = A[0];
dp[0][1] = B[0];
dp[0][2] = C[0];
for (int i = 1; i < n; i++) {
dp[i][0] = 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])) << "\n";
} | [
"assignment.value.change",
"identifier.change"
] | 963,180 | 963,181 | u527398664 | cpp |
p03162 | // dp_c_p3.cc
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<vector<int>> days(3, vector<int>(n));
for (int i = 0; i < n; i++) {
scanf("%d%d%d", &days[0][i], &days[1][i], &days[2][i]);
}
vector<vector<int>> dp(3, vector<int>(n, 0));
dp[0][0] = days[0][0];
dp[1][0] = days[1][0];
dp[2][0] = days[2][0];
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
if (j != k)
dp[j][i] = max(dp[j][i], dp[j][i - 1] + days[k][i]);
}
}
}
int ans = 0;
ans = max({ans, dp[0].back(), dp[1].back(), dp[2].back()});
printf("%d\n", ans);
} | // dp_c_p3.cc
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<vector<int>> days(3, vector<int>(n));
for (int i = 0; i < n; i++) {
scanf("%d%d%d", &days[0][i], &days[1][i], &days[2][i]);
}
vector<vector<int>> dp(3, vector<int>(n, 0));
dp[0][0] = days[0][0];
dp[1][0] = days[1][0];
dp[2][0] = days[2][0];
for (int i = 1; i < n; i++) {
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
if (j == k)
continue;
dp[j][i] = max(dp[j][i], dp[k][i - 1] + days[j][i]);
}
}
}
int ans = 0;
ans = max({ans, dp[0].back(), dp[1].back(), dp[2].back()});
printf("%d\n", ans);
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"assignment.value.change",
"call.arguments.change",
"expression.oper... | 963,187 | 963,188 | u349225213 | cpp |
p03162 | // dp_c_p3.cc
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<vector<int>> days(3, vector<int>(n));
for (int i = 0; i < n; i++) {
scanf("%d%d%d", &days[0][i], &days[1][i], &days[2][i]);
}
vector<vector<int>> dp(3, vector<int>(n, 0));
dp[0][0] = days[0][0];
dp[1][0] = days[1][0];
dp[2][0] = days[2][0];
for (int i = 1; i < n; i++) {
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
if (j == k)
continue;
dp[j][i] = max(dp[j][i], dp[j][i - 1] + days[k][i]);
}
}
}
int ans = 0;
ans = max({ans, dp[0].back(), dp[1].back(), dp[2].back()});
printf("%d\n", ans);
} | // dp_c_p3.cc
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<vector<int>> days(3, vector<int>(n));
for (int i = 0; i < n; i++) {
scanf("%d%d%d", &days[0][i], &days[1][i], &days[2][i]);
}
vector<vector<int>> dp(3, vector<int>(n, 0));
dp[0][0] = days[0][0];
dp[1][0] = days[1][0];
dp[2][0] = days[2][0];
for (int i = 1; i < n; i++) {
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
if (j == k)
continue;
dp[j][i] = max(dp[j][i], dp[k][i - 1] + days[j][i]);
}
}
}
int ans = 0;
ans = max({ans, dp[0].back(), dp[1].back(), dp[2].back()});
printf("%d\n", ans);
} | [
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 963,189 | 963,188 | u349225213 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll inf = 1e10;
int main() {
ll n;
cin >> n;
vector<vector<ll>> v(n, vector<ll>(3));
for (ll i = 0; i < n; ++i) {
for (ll j = 0; j < 3; ++j)
cin >> v[i][j];
}
vector<vector<ll>> dp(n, vector<ll>(3));
dp[0] = v[0];
for (ll i = 1; i < n; ++i) {
for (ll j = 0; j < 3; ++j) {
ll tmp = 0;
for (ll k = 0; k < 3; ++k) {
if (j == k)
continue;
tmp = max(tmp, dp[i - 1][j] + v[i][k]);
}
dp[i][j] = tmp;
}
}
cout << *max_element(dp.back().begin(), dp.back().end()) << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll inf = 1e10;
int main() {
ll n;
cin >> n;
vector<vector<ll>> v(n, vector<ll>(3));
for (ll i = 0; i < n; ++i) {
for (ll j = 0; j < 3; ++j)
cin >> v[i][j];
}
vector<vector<ll>> dp(n, vector<ll>(3));
dp[0] = v[0];
for (ll i = 1; i < n; ++i) {
for (ll j = 0; j < 3; ++j) {
ll tmp = 0;
for (ll k = 0; k < 3; ++k) {
if (j == k)
continue;
tmp = max(tmp, dp[i - 1][k] + v[i][j]);
}
dp[i][j] = tmp;
}
}
cout << *max_element(dp.back().begin(), dp.back().end()) << endl;
}
| [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 963,190 | 963,191 | u698760125 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll inf = 1e10;
int main() {
ll n;
cin >> n;
vector<vector<ll>> v(n, vector<ll>(3));
for (ll i = 0; i < n; ++i) {
for (ll j = 0; j < 3; ++j)
cin >> v[i][j];
}
vector<vector<ll>> dp(n, vector<ll>(3));
dp[0] = v[0];
for (ll i = 1; i < n; ++i) {
for (ll j = 0; j < 3; ++j) {
ll tmp = 0;
for (ll k = 0; k < 3; ++k) {
if (j == k)
continue;
tmp = max(tmp, dp[i - 1][j] + v[i][k]);
}
dp[i][j] = tmp;
}
}
cout << *max_element(dp.back().begin(), dp.back().end());
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll inf = 1e10;
int main() {
ll n;
cin >> n;
vector<vector<ll>> v(n, vector<ll>(3));
for (ll i = 0; i < n; ++i) {
for (ll j = 0; j < 3; ++j)
cin >> v[i][j];
}
vector<vector<ll>> dp(n, vector<ll>(3));
dp[0] = v[0];
for (ll i = 1; i < n; ++i) {
for (ll j = 0; j < 3; ++j) {
ll tmp = 0;
for (ll k = 0; k < 3; ++k) {
if (j == k)
continue;
tmp = max(tmp, dp[i - 1][k] + v[i][j]);
}
dp[i][j] = tmp;
}
}
cout << *max_element(dp.back().begin(), dp.back().end()) << endl;
}
| [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.newline.add"
] | 963,192 | 963,191 | u698760125 | cpp |
p03162 | #include <bits/stdc++.h>
#define m 1000000007
using namespace std;
int main() {
long long n, k, q;
cin >> n;
long long h[n + 1], dp1[n + 1], dp2[n + 1], dp3[n + 1], a[n + 1], b[n + 1],
c[n + 1], last;
for (int i = 1; i <= n; ++i) {
cin >> a[i] >> b[i] >> c[i];
}
dp1[1] = a[1];
dp2[1] = b[1];
dp3[1] = c[1];
last = a[1];
for (int i = 2; i <= n; ++i) {
dp1[i] = a[i] + max(dp2[i - 1], dp3[i - 1]);
dp2[i] = a[i] + max(dp1[i - 1], dp3[i - 1]);
dp3[i] = a[i] + max(dp1[i - 1], dp2[i - 1]);
}
cout << max(max(dp1[n], dp2[n]), dp3[n]);
}
/*int main()
{
long long t;
cin>>t;
string s1,s2;
for (int i = 0; i < 2*k; ++i)
{
cin>>s1>>s2;
}
for (int i = s1.length(); i > 0; --i)
{
}
}*/ | #include <bits/stdc++.h>
#define m 1000000007
using namespace std;
int main() {
long long n, k, q;
cin >> n;
long long h[n + 1], dp1[n + 1], dp2[n + 1], dp3[n + 1], a[n + 1], b[n + 1],
c[n + 1], last;
for (int i = 1; i <= n; ++i) {
cin >> a[i] >> b[i] >> c[i];
}
dp1[1] = a[1];
dp2[1] = b[1];
dp3[1] = c[1];
last = a[1];
for (int i = 2; i <= n; ++i) {
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]);
}
cout << max(max(dp1[n], dp2[n]), dp3[n]);
}
/*int main()
{
long long t;
cin>>t;
string s1,s2;
for (int i = 0; i < 2*k; ++i)
{
cin>>s1>>s2;
}
for (int i = s1.length(); i > 0; --i)
{
}
}*/ | [
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 963,193 | 963,194 | u322913626 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define fastio \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define pb push_back
#define ll long long
#define mp make_pair
#define MAXN 1e6
const int mod = 1e9 + 7;
void solve() {
int n, x;
cin >> n;
vector<int> dp(3);
for (int i = 0; i < n; i++) {
vector<int> new_dp(3, 0);
vector<int> c(3);
for (int j = 0; j < 3; j++)
cin >> c[i];
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] + c[k]);
}
}
}
dp = new_dp;
}
cout << max({dp[0], dp[1], dp[2]});
}
int main() { fastio solve(); }
| #include <bits/stdc++.h>
using namespace std;
#define fastio \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define pb push_back
#define ll long long
#define mp make_pair
#define MAXN 1e6
const int mod = 1e9 + 7;
void solve() {
int n, x;
cin >> n;
vector<int> dp(3);
for (int i = 0; i < n; i++) {
vector<int> new_dp(3, 0);
vector<int> c(3);
for (int j = 0; j < 3; j++)
cin >> c[j];
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
if (j != k) {
new_dp[k] = max(new_dp[k], dp[j] + c[k]);
}
}
}
dp = new_dp;
}
cout << max({dp[0], dp[1], dp[2]});
}
int main() { fastio solve(); }
| [
"identifier.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 963,197 | 963,198 | u955792251 | cpp |
p03162 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
int maxPointsDP(int **arr, int m, int lastN) {
int **dp = new int *[m + 1];
for (int i = 0; i <= m; i++) {
dp[i] = new int[4];
for (int j = 0; j <= 3; j++) {
dp[i][j] = 0;
}
}
for (int j = 1; j <= 3; j++) {
dp[0][j] = 0;
}
for (int j = 1; j <= 3; j++) {
dp[1][j] = arr[0][j - 1];
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= 3; j++) {
int first = j == 1 ? INT_MIN : arr[i - 1][j - 1] + dp[i - 1][j];
int second = j == 2 ? INT_MIN : arr[i - 1][j - 1] + dp[i - 1][j];
int third = j == 3 ? INT_MIN : arr[i - 1][j - 1] + dp[i - 1][j];
dp[i][j] = max(first, max(second, third));
}
}
int ans = INT_MIN;
for (int j = 1; j <= 3; j++) {
ans = max(ans, dp[m][j]);
}
return ans;
}
int main() {
int m, n = 3;
cin >> m;
int **arr = new int *[m];
for (int i = 0; i < m; i++) {
arr[i] = new int[n];
for (int j = 0; j < n; j++) {
cin >> arr[i][j];
}
}
cout << maxPointsDP(arr, m, -1);
return 0;
} | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
int maxPointsDP(int **arr, int m, int lastN) {
int **dp = new int *[m + 1];
for (int i = 0; i <= m; i++) {
dp[i] = new int[4];
for (int j = 0; j <= 3; j++) {
dp[i][j] = 0;
}
}
for (int j = 1; j <= 3; j++) {
dp[0][j] = 0;
}
for (int j = 1; j <= 3; j++) {
dp[1][j] = arr[0][j - 1];
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= 3; j++) {
int first = j == 1 ? INT_MIN : arr[i - 1][j - 1] + dp[i - 1][1];
int second = j == 2 ? INT_MIN : arr[i - 1][j - 1] + dp[i - 1][2];
int third = j == 3 ? INT_MIN : arr[i - 1][j - 1] + dp[i - 1][3];
dp[i][j] = max(first, max(second, third));
}
}
int ans = INT_MIN;
for (int j = 1; j <= 3; j++) {
ans = max(ans, dp[m][j]);
}
return ans;
}
int main() {
int m, n = 3;
cin >> m;
int **arr = new int *[m];
for (int i = 0; i < m; i++) {
arr[i] = new int[n];
for (int j = 0; j < n; j++) {
cin >> arr[i][j];
}
}
cout << maxPointsDP(arr, m, -1);
return 0;
} | [
"identifier.replace.remove",
"literal.replace.add",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 963,199 | 963,200 | u833540569 | cpp |
p03162 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
int maxPointsDP(int **arr, int m, int lastN) {
int **dp = new int *[m + 1];
for (int i = 0; i <= m; i++) {
dp[i] = new int[4];
for (int j = 0; j <= 3; j++) {
dp[i][j] = 0;
}
}
for (int j = 1; j <= 3; j++) {
dp[0][j] = 0;
}
for (int j = 1; j <= 3; j++) {
dp[1][j] = arr[0][j - 1];
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= 3; j++) {
int first = j == 1 ? INT_MIN : arr[i - 1][j - 1] + dp[i - 1][j];
int second = j == 2 ? INT_MIN : arr[i - 1][j - 1] + dp[i - 1][j];
int third = j == 3 ? INT_MIN : arr[i - 1][j - 1] + dp[i - 1][j];
dp[i][j] = max(first, max(second, third));
}
}
int ans = INT_MIN;
for (int j = 1; j <= 3; j++) {
ans = max(ans, dp[m][j]);
}
return ans;
}
int main() {
int m, n = 3;
cin >> m;
int **arr = new int *[m];
for (int i = 0; i < m; i++) {
arr[i] = new int[n];
for (int j = 0; j < n; j++) {
cin >> arr[i][j];
}
}
cout << maxPointsDP(arr, m, -1);
return 0;
} | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
int maxPointsDP(int **arr, int m, int lastN) {
int **dp = new int *[m + 1];
for (int i = 0; i <= m; i++) {
dp[i] = new int[4];
for (int j = 0; j <= 3; j++) {
dp[i][j] = 0;
}
}
for (int j = 1; j <= 3; j++) {
dp[0][j] = 0;
}
for (int j = 1; j <= 3; j++) {
dp[1][j] = arr[0][j - 1];
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= 3; j++) {
int first = j == 1 ? INT_MIN : arr[i - 1][j - 1] + dp[i - 1][1];
int second = j == 2 ? INT_MIN : arr[i - 1][j - 1] + dp[i - 1][2];
int third = j == 3 ? INT_MIN : arr[i - 1][j - 1] + dp[i - 1][3];
dp[i][j] = max(first, max(second, third));
}
}
int ans = INT_MIN;
for (int j = 1; j <= 3; j++) {
ans = max(ans, dp[m][j]);
}
return ans;
}
int main() {
int m, n = 3;
cin >> m;
int **arr = new int *[m];
for (int i = 0; i < m; i++) {
arr[i] = new int[n];
for (int j = 0; j < n; j++) {
cin >> arr[i][j];
}
}
cout << maxPointsDP(arr, m, -1);
return 0;
} | [
"identifier.replace.remove",
"literal.replace.add",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 963,201 | 963,200 | u833540569 | cpp |
p03162 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
vector<vector<int>> input(N, vector<int>(3));
vector<int> dp(3);
for (int i = 0; i < N; i++) {
for (int j = 0; j < 3; j++) {
cin >> input[i][j];
}
}
dp[0] = input[0][0];
dp[0] = input[0][1];
dp[0] = input[0][2];
for (int i = 1; i < N; i++) {
vector<int> new_dp(3);
new_dp[0] = input[i][0] + max(dp[1], dp[2]);
new_dp[1] = input[i][1] + max(dp[2], dp[0]);
new_dp[2] = input[i][2] + max(dp[0], dp[1]);
dp = new_dp;
}
int res = max(dp[0], max(dp[1], dp[2]));
cout << res << endl;
}
| #include <iostream>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
vector<vector<int>> input(N, vector<int>(3));
vector<int> dp(3);
for (int i = 0; i < N; i++) {
for (int j = 0; j < 3; j++) {
cin >> input[i][j];
}
}
dp[0] = input[0][0];
dp[1] = input[0][1];
dp[2] = input[0][2];
for (int i = 1; i < N; i++) {
vector<int> new_dp(3);
new_dp[0] = input[i][0] + max(dp[1], dp[2]);
new_dp[1] = input[i][1] + max(dp[2], dp[0]);
new_dp[2] = input[i][2] + max(dp[0], dp[1]);
dp = new_dp;
}
int res = max(dp[0], max(dp[1], dp[2]));
cout << res << endl;
}
| [
"literal.number.change",
"assignment.variable.change",
"variable_access.subscript.index.change"
] | 963,203 | 963,204 | u638254110 | cpp |
p03162 | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <functional>
using namespace std;
#define int long long
#define double long double
#define FAST \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define mod 1000000007
using namespace __gnu_pbds;
typedef tree<int, null_type, less_equal<int>, rb_tree_tag,
tree_order_statistics_node_update>
new_data_set;
bool isprime(int n) {
if (n == 1)
return true;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
int lcm(int a, int b) { return (a * b) / __gcd(a, b); }
int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
unsigned int factorial(unsigned int n) {
if (n == 0)
return 1;
return n * factorial(n - 1);
}
const int inf = 1e17 + 7;
// const int N=2e5+5;
bool visited[100005] = {false};
signed main() {
FAST int n;
cin >> n;
vector<int> ans(3, 0);
for (int i = 0; i < n; i++) {
vector<int> dp(3, 0);
vector<int> b(3);
for (int i = 0; i < 3; i++)
cin >> b[i];
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
if (j != k) {
dp[k] = max(dp[k], ans[i] + b[j]);
}
}
}
ans = dp;
}
cout << max({ans[0], ans[1], ans[2]});
} | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <functional>
using namespace std;
#define int long long
#define double long double
#define FAST \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define mod 1000000007
using namespace __gnu_pbds;
typedef tree<int, null_type, less_equal<int>, rb_tree_tag,
tree_order_statistics_node_update>
new_data_set;
bool isprime(int n) {
if (n == 1)
return true;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
int lcm(int a, int b) { return (a * b) / __gcd(a, b); }
int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
unsigned int factorial(unsigned int n) {
if (n == 0)
return 1;
return n * factorial(n - 1);
}
const int inf = 1e17 + 7;
// const int N=2e5+5;
bool visited[100005] = {false};
signed main() {
FAST int n;
cin >> n;
vector<int> ans(3, 0);
for (int i = 0; i < n; i++) {
vector<int> dp(3, 0);
vector<int> b(3);
for (int i = 0; i < 3; i++)
cin >> b[i];
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
if (j != k) {
dp[k] = max(dp[k], ans[j] + b[k]);
}
}
}
ans = dp;
}
cout << max({ans[0], ans[1], ans[2]});
} | [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 963,212 | 963,213 | u450781068 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define MAX 1000001
#define N 1000000007
ll n;
ll a[100001][3];
ll dp[100001][3];
bool prime[MAX];
ll func(ll i, ll j) {
if (dp[i][j] != -1)
return dp[i][j];
if (i == n - 1)
dp[i][j] = a[i][j];
else {
ll res = 0;
for (ll k = 0; k < 3; k++) {
if (k != j) {
res = max(res, func(i + 1, k));
}
}
dp[i][j] = res + a[i][j];
}
return dp[i][j];
}
int main() {
ll t;
cin >> t;
while (t--) {
ll i, k, j, f, x, ans = 0;
cin >> n;
for (i = 0; i < n; i++) {
for (j = 0; j < 3; j++)
cin >> a[i][j];
}
memset(dp, -1, sizeof(dp));
for (j = 0; j < 3; j++)
ans = max(ans, func(0, j));
cout << ans << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define MAX 1000001
#define N 1000000007
ll n;
ll a[100001][3];
ll dp[100001][3];
bool prime[MAX];
ll func(ll i, ll j) {
if (dp[i][j] != -1)
return dp[i][j];
if (i == n - 1)
dp[i][j] = a[i][j];
else {
ll res = 0;
for (ll k = 0; k < 3; k++) {
if (k != j) {
res = max(res, func(i + 1, k));
}
}
dp[i][j] = res + a[i][j];
}
return dp[i][j];
}
int main() {
ll t = 1;
// cin>>t;
while (t--) {
ll i, k, j, f, x, ans = 0;
cin >> n;
for (i = 0; i < n; i++) {
for (j = 0; j < 3; j++)
cin >> a[i][j];
}
memset(dp, -1, sizeof(dp));
for (j = 0; j < 3; j++)
ans = max(ans, func(0, j));
cout << ans << endl;
}
return 0;
}
| [
"expression.operation.binary.remove"
] | 963,214 | 963,215 | u818482882 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define fastio \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define int long long
int dp[100005][3];
int a[100005][3];
int n;
int func(int i, int prev) {
if (i == n)
return 0;
if (dp[i][prev] != -1)
return dp[i][prev];
int ans = 0;
if (prev != 0)
ans = max(ans, a[i][0] + func(i + 1, 0));
if (prev != 1)
ans = max(ans, a[i][1] + func(i + 1, 1));
if (prev != 2)
ans = max(ans, a[i][2] + func(i + 1, 2));
dp[i][prev] = ans;
return dp[i][prev];
}
main() {
fastio;
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
cin >> a[i][j];
}
}
memset(dp, -1, sizeof(dp));
cout << func(0, 0);
} | #include <bits/stdc++.h>
using namespace std;
#define fastio \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define int long long
int dp[100005][4];
int a[100005][3];
int n;
int func(int i, int prev) {
if (i == n)
return 0;
if (dp[i][prev] != -1)
return dp[i][prev];
int ans = 0;
if (prev != 0)
ans = max(ans, a[i][0] + func(i + 1, 0));
if (prev != 1)
ans = max(ans, a[i][1] + func(i + 1, 1));
if (prev != 2)
ans = max(ans, a[i][2] + func(i + 1, 2));
dp[i][prev] = ans;
return dp[i][prev];
}
main() {
fastio;
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
cin >> a[i][j];
}
}
memset(dp, -1, sizeof(dp));
cout << func(0, 3);
}
| [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"io.output.change"
] | 963,241 | 963,242 | u394656605 | cpp |
p03162 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int cost(int N, vector<vector<int>> dp) {
for (int i = N - 1; i >= 0; i--) {
for (int j = 0; j < 3; j++) {
cout << i;
if (i == N - 1) {
continue;
} else if (j == 0)
dp[i][j] = max(dp[i + 1][1], dp[i + 1][2]) + dp[i][j];
else if (j == 1)
dp[i][j] = max(dp[i + 1][0], dp[i + 1][2]) + dp[i][j];
else
dp[i][j] = max(dp[i + 1][0], dp[i + 1][1]) + dp[i][j];
}
}
return max({dp[0][0], dp[0][1], dp[0][2]});
}
int main() {
int N;
cin >> N;
vector<vector<int>> vac;
for (int i = 0; i < N; i++) {
vector<int> D;
int x;
for (int j = 0; j < 3; j++) {
cin >> x;
D.push_back(x);
}
vac.push_back(D);
}
int value = cost(N, vac);
cout << value;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int cost(int N, vector<vector<int>> dp) {
for (int i = N - 1; i >= 0; i--) {
for (int j = 0; j < 3; j++) {
if (i == N - 1) {
continue;
} else if (j == 0)
dp[i][j] = max(dp[i + 1][1], dp[i + 1][2]) + dp[i][j];
else if (j == 1)
dp[i][j] = max(dp[i + 1][0], dp[i + 1][2]) + dp[i][j];
else
dp[i][j] = max(dp[i + 1][0], dp[i + 1][1]) + dp[i][j];
}
}
return max({dp[0][0], dp[0][1], dp[0][2]});
}
int main() {
int N;
cin >> N;
vector<vector<int>> vac;
for (int i = 0; i < N; i++) {
vector<int> D;
int x;
for (int j = 0; j < 3; j++) {
cin >> x;
D.push_back(x);
}
vac.push_back(D);
}
int value = cost(N, vac);
cout << value;
return 0;
} | [] | 963,250 | 963,251 | u280697499 | cpp |
p03162 | #include <bits/stdc++.h>
int main() {
int n, v;
scanf("%d", &n);
std::vector<int> dp(3, 0);
for (int d = 0; d < n; ++d) {
std::vector<int> tmp_dp(3, 0);
for (int i = 0; i < 3; ++i) {
scanf("%d", &v);
for (int j = 0; j < 3; ++j) {
if (i != j) {
tmp_dp[i] = std::max(tmp_dp[i], dp[j] + v);
}
}
dp = tmp_dp;
}
}
printf("%d\n", std::max({dp[0], dp[1], dp[2]}));
return 0;
} | #include <bits/stdc++.h>
int main() {
int n, v;
scanf("%d", &n);
std::vector<int> dp(3, 0);
for (int d = 0; d < n; ++d) {
std::vector<int> tmp_dp(3, 0);
for (int i = 0; i < 3; ++i) {
scanf("%d", &v);
for (int j = 0; j < 3; ++j) {
if (i != j) {
tmp_dp[i] = std::max(tmp_dp[i], dp[j] + v);
}
}
}
dp = tmp_dp;
}
printf("%d\n", std::max({dp[0], dp[1], dp[2]}));
return 0;
} | [] | 963,256 | 963,257 | u158312277 | cpp |
p03162 | #include <bits/stdc++.h>
#define endl "\n"
#define ll long long int
#define pii pair<int, int>
#define pll pair<long long, long long>
#define inf 1000000000000000001;
#define all(c) c.begin(), c.end()
#define mp(x, y) make_pair(x, y)
#define mem(a, val) memset(a, val, sizeof(a))
#define eb emplace_back
#define f first
#define pb push_back
#define MAXN 10000057
#define mod 1000000007
#define fr(i, s, e, st) for (ll(i) = (s); (i) < (e); (i) += (st))
#define fre(i, s, e, st) for (ll(i) = (s); (i) <= (e); (i) += (st))
#define fastio \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0); \
cout << fixed; \
cout << setprecision(10);
using namespace std;
int main() {
fastio;
ll T = 1;
// cin >> T;
while (T--) {
ll n, a, b, c;
cin >> n;
ll DP[n + 1][3];
mem(DP, 0);
fr(i, 0, n, 1) {
cin >> a >> b >> c;
DP[i + 1][0] = max(DP[i][1] + b, DP[i][1] + c);
DP[i + 1][1] = max(DP[i][0] + a, DP[i][2] + c);
DP[i + 1][2] = max(DP[i][0] + a, DP[i][1] + b);
}
cout << max({DP[n][0], DP[n][1], DP[n][2]}) << endl;
}
return 0;
} | #include <bits/stdc++.h>
#define endl "\n"
#define ll long long int
#define pii pair<int, int>
#define pll pair<long long, long long>
#define inf 1000000000000000001;
#define all(c) c.begin(), c.end()
#define mp(x, y) make_pair(x, y)
#define mem(a, val) memset(a, val, sizeof(a))
#define eb emplace_back
#define f first
#define pb push_back
#define MAXN 10000057
#define mod 1000000007
#define fr(i, s, e, st) for (ll(i) = (s); (i) < (e); (i) += (st))
#define fre(i, s, e, st) for (ll(i) = (s); (i) <= (e); (i) += (st))
#define fastio \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0); \
cout << fixed; \
cout << setprecision(10);
using namespace std;
int main() {
fastio;
ll T = 1;
// cin >> T;
while (T--) {
ll n, a, b, c;
cin >> n;
ll DP[n + 1][3];
mem(DP, 0);
fr(i, 0, n, 1) {
cin >> a >> b >> c;
DP[i + 1][0] = max(DP[i][1] + b, DP[i][2] + c);
DP[i + 1][1] = max(DP[i][0] + a, DP[i][2] + c);
DP[i + 1][2] = max(DP[i][0] + a, DP[i][1] + b);
}
cout << max({DP[n][0], DP[n][1], DP[n][2]}) << endl;
}
return 0;
} | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 963,262 | 963,263 | u938766060 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
int a[n][3], dp[n][3];
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
cin >> a[i][j];
}
}
for (int j = 0; j < 3; j++) {
dp[0][j] = a[0][j];
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < 3; j++) {
int mx = 0;
for (int k = 0; k < n; k++) {
if (j != k) {
mx = max(dp[i - 1][k], mx);
}
}
dp[i][j] = mx + a[i][j];
}
}
cout << max({dp[n - 1][2], dp[n - 1][1], dp[n - 1][0]}) << "\n";
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
int a[n][3], dp[n][3];
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
cin >> a[i][j];
}
}
for (int j = 0; j < 3; j++) {
dp[0][j] = a[0][j];
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < 3; j++) {
int mx = 0;
for (int k = 0; k < 3; k++) {
if (j != k) {
mx = max(dp[i - 1][k], mx);
}
}
dp[i][j] = mx + a[i][j];
}
}
cout << max({dp[n - 1][2], dp[n - 1][1], dp[n - 1][0]}) << "\n";
return 0;
}
| [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 963,279 | 963,280 | u845907943 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<vector<int>> arr(n, vector<int>(3));
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
cin >> arr[i][j];
}
}
for (int i = 1; i < n; i++) {
arr[i][0] += max(arr[i - 1][1], arr[i - 1][2]);
arr[i][1] += max(arr[i - 1][0], arr[i - 1][2]);
arr[i][2] += max(arr[i - 1][1], arr[i - 1][0]);
}
int ans = max(arr[n - 1][0], min(arr[n - 1][1], arr[n - 1][2]));
cout << ans << "\n";
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<vector<int>> arr(n, vector<int>(3));
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
cin >> arr[i][j];
}
}
for (int i = 1; i < n; i++) {
arr[i][0] += max(arr[i - 1][1], arr[i - 1][2]);
arr[i][1] += max(arr[i - 1][0], arr[i - 1][2]);
arr[i][2] += max(arr[i - 1][1], arr[i - 1][0]);
}
int ans = max(arr[n - 1][0], max(arr[n - 1][1], arr[n - 1][2]));
cout << ans << "\n";
}
| [
"misc.opposites",
"identifier.change",
"call.function.change",
"call.arguments.change"
] | 963,301 | 963,302 | u704524932 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &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) {
scanf("%d", &c[i]);
}
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 3; ++j) {
if (i != j) {
new_dp[i] = max(new_dp[i], dp[i] + c[j]);
}
}
}
dp = new_dp;
}
printf("%d\n", max({dp[0], dp[1], dp[2]}));
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &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) {
scanf("%d", &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;
}
printf("%d\n", max({dp[0], dp[1], dp[2]}));
}
| [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change",
"assignment.value.change",
"call.arguments.change"
] | 963,307 | 963,308 | u306697932 | cpp |
p03162 | #include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<ll, ll>;
//これを見る初心者の方へ:mainより上のいっぱい書いてあるやつはプログラムを簡略化するためのものです。自分も最近知りました。各種コメントをつけているので参考にしてみてください(検索すればqittaとかでも色々見つかるので探してみてください)
//マクロ
// forループ関係
//引数は、(ループ内変数,動く範囲)か(ループ内変数,始めの数,終わりの数)、のどちらか
// Dがついてないものはループ変数は1ずつインクリメントされ、Dがついてるものはループ変数は1ずつデクリメントされる
#define REP(i, n) for (ll i = 0; i < (ll)(n); i++)
#define REPD(i, n) for (ll i = n - 1; i >= 0; i--)
#define FOR(i, a, b) for (ll i = a; i < (ll)(b); i++)
#define FORD(i, a, b) for (ll i = a; i >= (ll)(b); i--)
// xにはvectorなどのコンテナ
#define ALL(x) (x).begin(), (x).end() // sortなどの引数を省略したい
#define sort(a) sort(ALL(a)) // sortの省略
#define SIZE(x) ((ll)(x).size()) // sizeをsize_tからllに直しておく
#define MAX(x) *max_element(ALL(x)) //最大値を求める
#define MIN(x) *min_element(ALL(x)) //最小値を求める
//定数
#define INF 1000000000000 // 10^12:極めて大きい値,∞
#define MOD 10000007 // 10^9+7:合同式の法
#define MAXR 100000 // 10^5:配列の最大のrange(素数列挙などで使用)
//略記
#define in(T, x) \
T x; \
cin >> x; // Tは型,xが入力値
#define vec(T, a, n, x) vector<T> a(n, x);
#define vec2(T, a, n, m) vector<vector<T>> a(n, vector<T>(m));
#define PB push_back // vectorヘの挿入
#define MP make_pair // pairのコンストラクタ
#define F first // pairの一つ目の要素
#define S second // pairの二つ目の要素
#define out(x) cout << x << endl //出力
#define bout(b) \
if (b) { \
out("Yes"); \
} else { \
out("No"); \
} //真偽問題に対する出力
#define ain(T, a, n) \
vector<T> a(n); \
REP(i, n) { cin >> a[i]; } //配列の宣言と入力
#define a2in(T1, a, T2, b, n) \
vector<T1> a(n); \
vector<T2> b(n); \
REP(i, n) { cin >> a[i] >> b[i]; } // 2つの配列を同時宣言、入力
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
} // dp表とかで最大値更新するやつ
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
} //最小値更新
signed main() {
in(ll, N);
ll dp[10010][3];
ll h[10010][3];
REP(i, N) {
REP(j, 2) { cin >> h[i][j]; }
}
REP(i, N) {
REP(j, 3) {
REP(k, 3) {
if (j == k)
continue;
chmax(dp[i + 1][k], dp[i][j] + h[i][k]);
}
}
}
ll ans = 0;
REP(i, 3) chmax(ans, dp[N][i]);
out(ans);
} | #include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<ll, ll>;
//これを見る初心者の方へ:mainより上のいっぱい書いてあるやつはプログラムを簡略化するためのものです。自分も最近知りました。各種コメントをつけているので参考にしてみてください(検索すればqittaとかでも色々見つかるので探してみてください)
//マクロ
// forループ関係
//引数は、(ループ内変数,動く範囲)か(ループ内変数,始めの数,終わりの数)、のどちらか
// Dがついてないものはループ変数は1ずつインクリメントされ、Dがついてるものはループ変数は1ずつデクリメントされる
#define REP(i, n) for (ll i = 0; i < (ll)(n); i++)
#define REPD(i, n) for (ll i = n - 1; i >= 0; i--)
#define FOR(i, a, b) for (ll i = a; i < (ll)(b); i++)
#define FORD(i, a, b) for (ll i = a; i >= (ll)(b); i--)
// xにはvectorなどのコンテナ
#define ALL(x) (x).begin(), (x).end() // sortなどの引数を省略したい
#define sort(a) sort(ALL(a)) // sortの省略
#define SIZE(x) ((ll)(x).size()) // sizeをsize_tからllに直しておく
#define MAX(x) *max_element(ALL(x)) //最大値を求める
#define MIN(x) *min_element(ALL(x)) //最小値を求める
//定数
#define INF 1000000000000 // 10^12:極めて大きい値,∞
#define MOD 10000007 // 10^9+7:合同式の法
#define MAXR 100000 // 10^5:配列の最大のrange(素数列挙などで使用)
//略記
#define in(T, x) \
T x; \
cin >> x; // Tは型,xが入力値
#define vec(T, a, n, x) vector<T> a(n, x);
#define vec2(T, a, n, m) vector<vector<T>> a(n, vector<T>(m));
#define PB push_back // vectorヘの挿入
#define MP make_pair // pairのコンストラクタ
#define F first // pairの一つ目の要素
#define S second // pairの二つ目の要素
#define out(x) cout << x << endl //出力
#define bout(b) \
if (b) { \
out("Yes"); \
} else { \
out("No"); \
} //真偽問題に対する出力
#define ain(T, a, n) \
vector<T> a(n); \
REP(i, n) { cin >> a[i]; } //配列の宣言と入力
#define a2in(T1, a, T2, b, n) \
vector<T1> a(n); \
vector<T2> b(n); \
REP(i, n) { cin >> a[i] >> b[i]; } // 2つの配列を同時宣言、入力
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
} // dp表とかで最大値更新するやつ
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
} //最小値更新
signed main() {
in(ll, N);
ll dp[100010][3];
ll h[100010][3];
REP(i, N) {
REP(j, 3) { cin >> h[i][j]; }
}
REP(i, N) {
REP(j, 3) {
REP(k, 3) {
if (j == k)
continue;
chmax(dp[i + 1][k], dp[i][j] + h[i][k]);
}
}
}
ll ans = 0;
REP(i, 3) chmax(ans, dp[N][i]);
out(ans);
} | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"call.arguments.change"
] | 963,317 | 963,316 | u457601965 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
#define ALL(x) (x).begin(), (x).end()
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define pb push_back
typedef vector<int> vint;
typedef vector<ll> vll;
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (auto &v : vec)
is >> v;
return is;
}
template <typename A, typename B> inline void chmin(A &a, B b) {
if (a > b)
a = b;
}
template <typename A, typename B> inline void chmax(A &a, B b) {
if (a < b)
a = b;
}
int main() {
int N;
cin >> N;
int a[N][3];
REP(i, N) cin >> a[i][0] >> a[i][1] >> a[i][2];
vector<vector<int>> dp(N + 1, vector<int>(3));
REP(now, N) {
REP(i, 3) {
REP(j, 3) {
if (i == j)
continue;
chmax(dp[now + 1][j], dp[now][j] + a[now][i]);
}
}
}
cout << max({dp[N][0], dp[N][1], dp[N][2]}) << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
#define ALL(x) (x).begin(), (x).end()
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define pb push_back
typedef vector<int> vint;
typedef vector<ll> vll;
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (auto &v : vec)
is >> v;
return is;
}
template <typename A, typename B> inline void chmin(A &a, B b) {
if (a > b)
a = b;
}
template <typename A, typename B> inline void chmax(A &a, B b) {
if (a < b)
a = b;
}
int main() {
int N;
cin >> N;
int a[N][3];
REP(i, N) cin >> a[i][0] >> a[i][1] >> a[i][2];
vector<vector<int>> dp(N + 1, vector<int>(3));
REP(now, N) {
REP(i, 3) {
REP(j, 3) {
if (i == j)
continue;
chmax(dp[now + 1][j], dp[now][i] + a[now][j]);
}
}
}
cout << max({dp[N][0], dp[N][1], dp[N][2]}) << endl;
} | [
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 963,318 | 963,319 | u978308810 | cpp |
p03162 | #include <bits/stdc++.h>
#define ll long long;
using namespace std;
int a[100005][3];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, sum = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 3; j++)
cin >> a[i][j];
if (i != 1) {
for (int j = 0; j < 3; j++)
a[i][j] += max(a[i - 1][(j + 1) % 3], a[i - 1][(j + 2) % 3]);
}
}
cout << max(a[n][1], max(a[n][1], a[n][2])) << "\n";
} | #include <bits/stdc++.h>
#define ll long long;
using namespace std;
int a[100005][3];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, sum = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 3; j++)
cin >> a[i][j];
if (i != 1) {
for (int j = 0; j < 3; j++)
a[i][j] += max(a[i - 1][(j + 1) % 3], a[i - 1][(j + 2) % 3]);
}
}
cout << max(a[n][1], max(a[n][0], a[n][2])) << "\n";
} | [
"literal.number.change",
"variable_access.subscript.index.change",
"io.output.change"
] | 963,323 | 963,324 | u663494838 | cpp |
p03162 | #define _USE_MATH_DEFINES
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cctype>
#include <climits>
#include <clocale>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
const int MOD = 1'000'000'007;
const int INF = 1'000'000'000; // 1e9
const int NIL = -1;
const long long LINF = 1'000'000'000'000'000'000; // 1e18
const long double EPS = 1E-10;
template <class T, class S> inline bool chmax(T &a, const S &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T, class S> inline bool chmin(T &a, const S &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
int main() {
int N;
std::cin >> N;
std::vector<std::vector<int>> abc(N, std::vector<int>(3));
std::vector<std::vector<int>> dp(N, std::vector<int>(3));
for (int i(0); i < N; ++i) {
for (int j(0); j < 3; ++j) {
std::cin >> abc[i][j];
}
}
for (int j(0); j < 3; ++j)
dp[0][j] = abc[0][j];
for (int i(2); i < N; ++i) {
for (int j(0); j < 3; ++j) {
for (int k(0); k < 3; ++k) {
if (j == k)
continue;
chmax(dp[i][j], dp[i - 1][k] + abc[i][j]);
}
}
}
int mx(0);
for (int j(0); j < 3; ++j)
chmax(mx, dp[N - 1][j]);
std::cout << mx << std::endl;
return 0;
}
| #define _USE_MATH_DEFINES
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cctype>
#include <climits>
#include <clocale>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
const int MOD = 1'000'000'007;
const int INF = 1'000'000'000; // 1e9
const int NIL = -1;
const long long LINF = 1'000'000'000'000'000'000; // 1e18
const long double EPS = 1E-10;
template <class T, class S> inline bool chmax(T &a, const S &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T, class S> inline bool chmin(T &a, const S &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
int main() {
int N;
std::cin >> N;
std::vector<std::vector<int>> abc(N, std::vector<int>(3));
std::vector<std::vector<int>> dp(N, std::vector<int>(3));
for (int i(0); i < N; ++i) {
for (int j(0); j < 3; ++j) {
std::cin >> abc[i][j];
}
}
for (int j(0); j < 3; ++j)
dp[0][j] = abc[0][j];
for (int i(1); i < N; ++i) {
for (int j(0); j < 3; ++j) {
for (int k(0); k < 3; ++k) {
if (j == k)
continue;
chmax(dp[i][j], dp[i - 1][k] + abc[i][j]);
}
}
}
int mx(0);
for (int j(0); j < 3; ++j)
chmax(mx, dp[N - 1][j]);
std::cout << mx << std::endl;
return 0;
}
| [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"call.arguments.change"
] | 963,325 | 963,326 | u803893892 | cpp |
p03162 | #include "bits/stdc++.h"
using namespace std;
#define ll long long
int main() {
int n;
cin >> n;
vector<vector<ll>> dp(n, vector<ll>(3, 0));
vector<vector<ll>> v(n, std::vector<ll>(3));
for (ll i = 0; i < n; i++) {
for (ll j = 0; j < 3; j++)
cin >> v[i][j];
}
for (ll i = 0; i < 3; i++)
dp[0][i] = v[0][i];
for (ll i = 1; i < n; i++) {
for (ll j = 0; j < 3; j++) {
for (ll k = 0; k < 3; k++) {
if (j != k) {
dp[i][j] = max(dp[i - 1][j], dp[i - 1][k] + v[i][j]);
}
}
}
}
cout << max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2])) << "\n";
return 0;
}
| #include "bits/stdc++.h"
using namespace std;
#define ll long long
int main() {
int n;
cin >> n;
vector<vector<ll>> dp(n, vector<ll>(3, 0));
vector<vector<ll>> v(n, std::vector<ll>(3));
for (ll i = 0; i < n; i++) {
for (ll j = 0; j < 3; j++)
cin >> v[i][j];
}
for (ll i = 0; i < 3; i++)
dp[0][i] = v[0][i];
for (ll i = 1; i < n; i++) {
for (ll j = 0; j < 3; j++) {
for (ll k = 0; k < 3; k++) {
if (j != k) {
dp[i][j] = max(dp[i][j], dp[i - 1][k] + v[i][j]);
}
}
}
}
cout << max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2])) << "\n";
return 0;
}
| [
"expression.operation.binary.remove"
] | 963,327 | 963,328 | u268041276 | cpp |
p03162 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iosfwd>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define lli long long int
#define lower(a) transform(a.begin(), a.end(), a.begin(), ::tolower);
using namespace std;
const int N = 3e5 + 500;
const long long mod = 1e9 + 7;
const long long INF = 1LL << 57;
const int M = 1e6 + 500;
lli dp[N][3];
void solve() {
lli n;
cin >> n;
lli a[n][3];
for (int i = 1; i <= n; i++)
cin >> a[i][0] >> a[i][1] >> a[i][2];
for (int i = 1; i <= n; i++) {
dp[i][0] = max(dp[i - 1][1], dp[i - 1][2]) + a[i][0];
dp[i][1] = max(dp[i - 1][0], dp[i - 1][2]) + a[i][1];
dp[i][2] = max(dp[i - 1][0], dp[i - 1][1]) + a[i][2];
}
cout << max(dp[n][0], max(dp[n][1], dp[n][2])) << endl;
return;
}
/*
10
6
10 3 2 5 7 8
*/
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
lli t;
t = 1;
// cin>>t;
while (t--) {
solve();
}
return 0;
}
| #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iosfwd>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define lli long long int
#define lower(a) transform(a.begin(), a.end(), a.begin(), ::tolower);
using namespace std;
const int N = 3e5 + 500;
const long long mod = 1e9 + 7;
const long long INF = 1LL << 57;
const int M = 1e6 + 500;
lli dp[N][3];
void solve() {
lli n;
cin >> n;
lli a[n + 1][3];
for (int i = 1; i <= n; i++)
cin >> a[i][0] >> a[i][1] >> a[i][2];
for (int i = 1; i <= n; i++) {
dp[i][0] = max(dp[i - 1][1], dp[i - 1][2]) + a[i][0];
dp[i][1] = max(dp[i - 1][0], dp[i - 1][2]) + a[i][1];
dp[i][2] = max(dp[i - 1][0], dp[i - 1][1]) + a[i][2];
}
cout << max(dp[n][0], max(dp[n][1], dp[n][2])) << endl;
return;
}
/*
10
6
10 3 2 5 7 8
*/
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
lli t;
t = 1;
// cin>>t;
while (t--) {
solve();
}
return 0;
}
| [
"variable_declaration.array_dimensions.change",
"expression.operation.binary.add"
] | 963,330 | 963,331 | u684423349 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
int n;
cin >> n;
vector<int> dp(3);
for (int day = 0; day < n; ++day) {
vector<int> c(3);
for (int i = 0; i < 3; ++i) {
cin >> c[i];
}
vector<int> new_dp(3, 0);
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 3; ++j) {
if (i != j) {
new_dp[j] = max(new_dp[j], new_dp[i] + c[j]);
}
}
}
dp = new_dp;
}
cout << max(dp[0], max(dp[1], dp[2])) << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
int n;
cin >> n;
vector<int> dp(3);
for (int day = 0; day < n; ++day) {
vector<int> c(3);
for (int i = 0; i < 3; ++i) {
cin >> c[i];
}
vector<int> new_dp(3, 0);
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;
} | [
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 963,341 | 963,342 | u863722262 | cpp |
p03162 | #include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
int N;
long long a[100010][3];
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 >> 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;
chmax(dp[i + 1][k], dp[i][j] + a[i][k]);
}
}
}
long long res = 0;
for (int i = 0; i < 3; i++)
res = chmax(res, dp[N][i]);
cout << res << endl;
}
| #include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
int N;
long long a[100010][3];
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 >> 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;
chmax(dp[i + 1][k], dp[i][j] + a[i][k]);
}
}
}
long long res = 0;
for (int i = 0; i < 3; i++)
chmax(res, dp[N][i]);
cout << res << endl;
}
| [
"assignment.change"
] | 963,347 | 963,348 | u731665172 | cpp |
p03162 | #include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
int N;
long long a[100010][3];
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 >> 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;
chmax(dp[i + 1][k], dp[i][j] + a[i][k]);
}
}
}
long long res = 0;
for (int i = 0; i < 3; i++)
res = chmax(res, dp[N - 1][i]);
cout << res << endl;
}
| #include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
int N;
long long a[100010][3];
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 >> 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;
chmax(dp[i + 1][k], dp[i][j] + a[i][k]);
}
}
}
long long res = 0;
for (int i = 0; i < 3; i++)
chmax(res, dp[N][i]);
cout << res << endl;
}
| [
"assignment.change",
"expression.operation.binary.remove"
] | 963,350 | 963,348 | u731665172 | cpp |
p03162 | #include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define n_p next_permutation
#define p_p prev_permutation
#define in insert
#define rev reverse
#define pf push_front
#define pob pop_back
#define all(x) (x).begin(), (x).end()
#define pof pop_front
#define ios \
ios_base::sync_with_stdio(0); \
cin.tie(); \
cout.tie();
#define scn scanf
#define prt printf
#define rep(i, a, n) for (int i = a; i < n; i++)
#define mod 998244353
using namespace std;
bool cmp(string s, string p) { return s.size() < p.size(); }
int main() {
int n;
cin >> n;
vector<int> dp(3);
for (int i = 0; i < n; i++) {
vector<int> n_dp(3);
vector<int> c(3);
for (int j = 0; j < 3; j++) {
cin >> c[j];
}
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
if (j != k) {
n_dp[k] = max(dp[k], dp[j] + c[k]);
}
}
}
dp = n_dp;
}
cout << max(max(dp[0], dp[1]), dp[2]) << "\n";
return 0;
}
| #include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define n_p next_permutation
#define p_p prev_permutation
#define in insert
#define rev reverse
#define pf push_front
#define pob pop_back
#define all(x) (x).begin(), (x).end()
#define pof pop_front
#define ios \
ios_base::sync_with_stdio(0); \
cin.tie(); \
cout.tie();
#define scn scanf
#define prt printf
#define rep(i, a, n) for (int i = a; i < n; i++)
#define mod 998244353
using namespace std;
bool cmp(string s, string p) { return s.size() < p.size(); }
int main() {
int n;
cin >> n;
vector<int> dp(3);
for (int i = 0; i < n; i++) {
vector<int> n_dp(3);
vector<int> c(3);
for (int j = 0; j < 3; j++) {
cin >> c[j];
}
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
if (j != k) {
n_dp[k] = max(n_dp[k], dp[j] + c[k]);
}
}
}
dp = n_dp;
}
cout << max(max(dp[0], dp[1]), dp[2]) << "\n";
return 0;
}
| [
"assignment.value.change",
"call.arguments.change"
] | 963,351 | 963,352 | u141362914 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int maxi(int a, int b, int c) {
if (a >= b && a >= c)
return a;
else if (b >= a && b >= c)
return b;
else
return c;
}
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 b[n][3];
b[0][0] = a[0][0];
b[0][1] = a[0][1];
b[0][2] = a[0][2];
for (int i = 1; i < n; i++) {
b[i][0] = a[i][0] + max(b[i - 1][1], b[i - 1][2]);
b[i][1] = a[i][1] + max(b[i - 1][0], b[i - 1][2]);
b[i][2] = a[i][2] + max(b[i - 1][0], b[i - 1][1]);
}
cout << maxi(b[n][0], b[n][1], b[n][2]);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int maxi(int a, int b, int c) {
if (a >= b && a >= c)
return a;
else if (b >= a && b >= c)
return b;
else
return c;
}
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 b[n][3];
b[0][0] = a[0][0];
b[0][1] = a[0][1];
b[0][2] = a[0][2];
for (int i = 1; i < n; i++) {
b[i][0] = a[i][0] + max(b[i - 1][1], b[i - 1][2]);
b[i][1] = a[i][1] + max(b[i - 1][0], b[i - 1][2]);
b[i][2] = a[i][2] + max(b[i - 1][0], b[i - 1][1]);
}
cout << maxi(b[n - 1][0], b[n - 1][1], b[n - 1][2]);
return 0;
}
| [
"expression.operation.binary.add"
] | 963,353 | 963,354 | u510784445 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n][3];
for (int i = 0; i < 3; i++) {
cin >> arr[i][0] >> arr[i][1] >> arr[i][2];
}
int dp[n][3];
dp[0][0] = arr[0][0];
dp[0][1] = arr[0][1];
dp[0][2] = arr[0][2];
for (int i = 1; i < n; i++) {
dp[i][0] = max(dp[i - 1][1] + arr[i][0], dp[i - 1][2] + arr[i][0]);
dp[i][1] = max(dp[i - 1][0] + arr[i][1], dp[i - 1][2] + arr[i][1]);
dp[i][2] = max(dp[i - 1][0] + arr[i][2], dp[i - 1][1] + arr[i][2]);
}
cout << max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2])) << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
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];
dp[0][0] = arr[0][0];
dp[0][1] = arr[0][1];
dp[0][2] = arr[0][2];
for (int i = 1; i < n; i++) {
dp[i][0] = max(dp[i - 1][1] + arr[i][0], dp[i - 1][2] + arr[i][0]);
dp[i][1] = max(dp[i - 1][0] + arr[i][1], dp[i - 1][2] + arr[i][1]);
dp[i][2] = max(dp[i - 1][0] + arr[i][2], dp[i - 1][1] + arr[i][2]);
}
cout << max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2])) << endl;
}
| [
"identifier.replace.add",
"literal.replace.remove",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 963,362 | 963,363 | u901327149 | cpp |
p03162 | #pragma region Template
#include <algorithm>
#include <bitset>
#include <cmath>
#include <fstream>
#include <iostream>
#include <limits.h>
#include <map>
#include <set>
#include <string>
#include <vector>
#define lli long long int
#define l long
#define us unsigned short
#define mod 1000000007
#define INF 1e9 + 5
#define vi vector<int>
#define vus vector<unsigned short>
#define vlli vector<long long int>
#define vs vector<string>
#define mii map<int, int>
#define w(t) \
int t; \
cin >> t; \
while (t--)
using namespace std;
#pragma endregion
int main() {
lli n;
cin >> n;
vlli dp(3);
for (int i = 0; i < n; i++) {
vlli c(3);
vlli ndp(3, -1);
for (int j = 0; j < 3; j++) {
cin >> c[j];
}
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
if (j != k) {
ndp[j] = max(ndp[j], dp[j] + c[k]);
}
}
}
dp = ndp;
}
lli m = min({dp[0], dp[1], dp[2]});
cout << m << endl;
return 0;
}
| #pragma region Template
#include <algorithm>
#include <bitset>
#include <cmath>
#include <fstream>
#include <iostream>
#include <limits.h>
#include <map>
#include <set>
#include <string>
#include <vector>
#define lli long long int
#define l long
#define us unsigned short
#define mod 1000000007
#define INF 1e9 + 5
#define vi vector<int>
#define vus vector<unsigned short>
#define vlli vector<long long int>
#define vs vector<string>
#define mii map<int, int>
#define w(t) \
int t; \
cin >> t; \
while (t--)
using namespace std;
#pragma endregion
int main() {
lli n;
cin >> n;
vlli dp(3);
for (int i = 0; i < n; i++) {
vlli c(3);
vlli ndp(3, -1);
for (int j = 0; j < 3; j++) {
cin >> c[j];
}
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
if (j != k) {
ndp[k] = max(ndp[k], dp[j] + c[k]);
}
}
}
dp = ndp;
}
lli m = max({dp[0], dp[1], dp[2]});
cout << m << endl;
return 0;
}
| [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change",
"assignment.value.change",
"call.arguments.change",
"misc.opposites",
"call.function.change"
] | 963,364 | 963,365 | u949194433 | cpp |
p03162 | #include <algorithm>
#include <array>
#include <cmath>
#include <cstdio>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
using namespace std;
#define i64 long long
#define int long long
#define I32_MAX 2147483647
#define I64_MAX 9223372036854775807
#define INF I64_MAX
#define MOD 1000000007
#define MEM_SIZE = 1e5 + 5;
template <typename T> void DEBUG(T e) {
std::cout << "DEBUG>>" << e << std::endl;
}
template <typename T> void DEBUG(const std::vector<T> &v) {
for (const auto &e : v) {
std::cout << e << " ";
}
std::cout << std::endl;
}
template <typename T> void DEBUG(const std::vector<std::vector<T>> &vv) {
for (const auto &v : vv) {
DEBUG(v);
}
}
void solve(void) {
int N;
cin >> N;
vector<vector<int>> DP(N, vector<int>(3, 0));
cin >> DP[0][0] >> DP[0][1] >> DP[0][2];
for (int i = 1; i < N; i++) {
vector<int> INPUT(3);
cin >> INPUT[0] >> INPUT[1] >> INPUT[2];
for (int r = 0; r < 3; r++) {
for (int p = 0; p < 3; p++) {
if (r != p) {
DP[i][r] = max(DP[i][p], DP[i][p] + INPUT[r]);
}
}
}
}
int ANS = 0;
for (int i = 0; i < 3; i++) {
ANS = max(DP[N - 1][i], ANS);
}
cout << ANS;
return;
}
int32_t main(int32_t argc, const char *argv[]) {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
std::cout << std::fixed;
std::cout << std::setprecision(8);
solve();
return 0;
} | #include <algorithm>
#include <array>
#include <cmath>
#include <cstdio>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
using namespace std;
#define i64 long long
#define int long long
#define I32_MAX 2147483647
#define I64_MAX 9223372036854775807
#define INF I64_MAX
#define MOD 1000000007
#define MEM_SIZE = 1e5 + 5;
template <typename T> void DEBUG(T e) {
std::cout << "DEBUG>>" << e << std::endl;
}
template <typename T> void DEBUG(const std::vector<T> &v) {
for (const auto &e : v) {
std::cout << e << " ";
}
std::cout << std::endl;
}
template <typename T> void DEBUG(const std::vector<std::vector<T>> &vv) {
for (const auto &v : vv) {
DEBUG(v);
}
}
void solve(void) {
int N;
cin >> N;
vector<vector<int>> DP(N, vector<int>(3, 0));
cin >> DP[0][0] >> DP[0][1] >> DP[0][2];
for (int i = 1; i < N; i++) {
vector<int> INPUT(3);
cin >> INPUT[0] >> INPUT[1] >> INPUT[2];
for (int r = 0; r < 3; r++) {
for (int p = 0; p < 3; p++) {
if (r != p) {
DP[i][r] = max(DP[i][r], DP[i - 1][p] + INPUT[r]);
}
}
}
}
int ANS = 0;
for (int i = 0; i < 3; i++) {
ANS = max(DP[N - 1][i], ANS);
}
cout << ANS;
return;
}
int32_t main(int32_t argc, const char *argv[]) {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
std::cout << std::fixed;
std::cout << std::setprecision(8);
solve();
return 0;
} | [
"assignment.value.change",
"call.arguments.change",
"assignment.change"
] | 963,374 | 963,375 | u221285045 | cpp |
p03162 | #pragma GCC optimize("Ofast", "unroll-loops")
#pragma GCC target("avx2,fma")
#include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (__typeof(a) i = (a); i < (b); ++i)
#define iter(it, c) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); ++it)
typedef pair<int, int> ii;
typedef vector<int> vi;
typedef vector<ii> vii;
typedef long long ll;
const int INF = ~(1 << 31);
#define sc second
#define fs first
#define pb push_back
const double EPS = 1e-9;
const double pi = acos(-1);
typedef unsigned long long ull;
typedef vector<vi> vvi;
typedef vector<vii> vvii;
template <class T> T smod(T a, T b) { return (a % b + b) % b; }
// vim: cc=60 ts=2 sts=2 sw=2:
int a[100'050], b[100'050], c[100'050];
ll memo[100'050][5];
ll dp(int at, int ban) {
if (at < 0)
return 0;
if (memo[at][ban] != -1)
return memo[at][ban];
ll bst = 0;
if (ban != 0)
bst = max(bst, dp(at - 1, 0) + a[at]);
if (ban != 1)
bst = max(bst, dp(at - 1, 1) + b[at]);
if (ban != 2)
bst = max(bst, dp(at - 1, 2) + c[at]);
return memo[at][ban] = bst;
}
int main() {
// code
memset(memo, -1, sizeof(memo));
int n;
cin >> n;
rep(i, 0, n) cin >> a[i] >> b[i] >> c[i];
cout << dp(n - 1, -1) << endl;
// codend
}
| #pragma GCC optimize("Ofast", "unroll-loops")
#pragma GCC target("avx2,fma")
#include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (__typeof(a) i = (a); i < (b); ++i)
#define iter(it, c) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); ++it)
typedef pair<int, int> ii;
typedef vector<int> vi;
typedef vector<ii> vii;
typedef long long ll;
const int INF = ~(1 << 31);
#define sc second
#define fs first
#define pb push_back
const double EPS = 1e-9;
const double pi = acos(-1);
typedef unsigned long long ull;
typedef vector<vi> vvi;
typedef vector<vii> vvii;
template <class T> T smod(T a, T b) { return (a % b + b) % b; }
// vim: cc=60 ts=2 sts=2 sw=2:
int a[100'050], b[100'050], c[100'050];
ll memo[100'050][5];
ll dp(int at, int ban) {
if (at < 0)
return 0;
if (memo[at][ban] != -1)
return memo[at][ban];
ll bst = 0;
if (ban != 0)
bst = max(bst, dp(at - 1, 0) + a[at]);
if (ban != 1)
bst = max(bst, dp(at - 1, 1) + b[at]);
if (ban != 2)
bst = max(bst, dp(at - 1, 2) + c[at]);
return memo[at][ban] = bst;
}
int main() {
// code
memset(memo, -1, sizeof(memo));
int n;
cin >> n;
rep(i, 0, n) cin >> a[i] >> b[i] >> c[i];
cout << dp(n - 1, 4) << endl;
// codend
}
| [
"literal.number.change",
"io.output.change",
"call.arguments.change"
] | 963,382 | 963,383 | u874174286 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
vector<int> dp(3);
for (int day = 0; day < 7; day++) {
vector<int> new_dp(3, 0);
int c[3];
cin >> c[0] >> c[1] >> c[2];
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (i != j) {
new_dp[j] = max(new_dp[j], dp[i] + c[j]);
}
}
}
dp = new_dp;
}
cout << max({dp[0], dp[1], dp[2]}) << 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);
int c[3];
cin >> c[0] >> c[1] >> c[2];
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (i != j) {
new_dp[j] = max(new_dp[j], dp[i] + c[j]);
}
}
}
dp = new_dp;
}
cout << max({dp[0], dp[1], dp[2]}) << endl;
}
int main() { solve(); } | [
"identifier.replace.add",
"literal.replace.remove",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 963,385 | 963,386 | u922347667 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
int64_t N, a0, b1, c2;
cin >> N;
vector<vector<int64_t>> dp(N, vector<int64_t>(3, 0));
cin >> a0 >> b1 >> c2;
dp.at(0).at(0) = a0;
dp.at(0).at(1) = b1;
dp.at(0).at(2) = c2;
for (int i = 1; i < N; i++) {
cin >> a0 >> b1 >> c2;
for (int j = 0; j < 3; j++) {
if (j == 0) {
dp.at(i).at(j) = a0 + max(dp.at(i - 1).at(1), dp.at(i - 1).at(2));
}
if (j == 1) {
dp.at(i).at(j) = b1 + max(dp.at(i - 1).at(0), dp.at(i - 1).at(2));
}
if (j == 2) {
dp.at(i).at(j) = c2 + max(dp.at(i - 1).at(0), dp.at(i - 1).at(1));
}
}
}
cout << max(dp.at(N - 1).at(0), (dp.at(N - 1).at(1), dp.at(N - 1).at(2)))
<< endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int64_t N, a0, b1, c2;
cin >> N;
vector<vector<int64_t>> dp(N, vector<int64_t>(3, 0));
cin >> a0 >> b1 >> c2;
dp.at(0).at(0) = a0;
dp.at(0).at(1) = b1;
dp.at(0).at(2) = c2;
for (int i = 1; i < N; i++) {
cin >> a0 >> b1 >> c2;
for (int j = 0; j < 3; j++) {
if (j == 0) {
dp.at(i).at(j) = a0 + max(dp.at(i - 1).at(1), dp.at(i - 1).at(2));
}
if (j == 1) {
dp.at(i).at(j) = b1 + max(dp.at(i - 1).at(0), dp.at(i - 1).at(2));
}
if (j == 2) {
dp.at(i).at(j) = c2 + max(dp.at(i - 1).at(0), dp.at(i - 1).at(1));
}
}
}
cout << max(dp.at(N - 1).at(0), max(dp.at(N - 1).at(1), dp.at(N - 1).at(2)))
<< endl;
}
| [
"call.add",
"call.arguments.change"
] | 963,390 | 963,391 | u875815230 | cpp |
p03162 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
int INF = 1e9;
int main() {
int n;
cin >> n;
vector<int> a(n), b(n), c(n);
rep(i, n) cin >> a[i] >> b[i] >> c[i];
vector<vector<int>> dp(n, vector<int>(3));
dp[0][0] = max(b[0], c[0]);
dp[0][1] = max(a[0], c[0]);
dp[0][2] = max(a[0], c[0]);
rep(i, n - 1) {
rep(j, 3) {
if (j == 0) {
dp[i + 1][j] = max(dp[i][1] + b[i + 1], dp[i][2] + c[i + 1]);
} else if (j == 1) {
dp[i + 1][j] = max(dp[i][0] + a[i + 1], dp[i][2] + c[i + 1]);
} else {
dp[i + 1][j] = max(dp[i][0] + a[i + 1], dp[i][1] + b[i + 1]);
}
}
}
cout << max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2])) << endl;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
int INF = 1e9;
int main() {
int n;
cin >> n;
vector<int> a(n), b(n), c(n);
rep(i, n) cin >> a[i] >> b[i] >> c[i];
vector<vector<int>> dp(n, vector<int>(3));
dp[0][0] = max(b[0], c[0]);
dp[0][1] = max(a[0], c[0]);
dp[0][2] = max(a[0], b[0]);
rep(i, n - 1) {
rep(j, 3) {
if (j == 0) {
dp[i + 1][j] = max(dp[i][1] + b[i + 1], dp[i][2] + c[i + 1]);
} else if (j == 1) {
dp[i + 1][j] = max(dp[i][0] + a[i + 1], dp[i][2] + c[i + 1]);
} else {
dp[i + 1][j] = max(dp[i][0] + a[i + 1], dp[i][1] + b[i + 1]);
}
}
}
cout << max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2])) << endl;
}
| [
"assignment.value.change",
"identifier.change",
"call.arguments.change"
] | 963,394 | 963,395 | u648009244 | cpp |
p03162 | #include <cmath>
#include <iostream>
#include <vector>
using namespace std;
int getMaxPoint(int n, vector<int> &a, vector<int> &b, vector<int> &c) {
vector<vector<int>> dp(n + 1, vector<int>(3, 0));
int cur = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < 3; ++j) {
cur = (i == 0) ? a[i - 1] : (i == 1 ? b[i - 1] : c[i - 1]);
dp[i][j] = max(dp[i][j], max(cur + dp[i - 1][(j + 1) % 3],
cur + dp[i - 1][(j + 2) % 3]));
}
}
return max(dp[n][0], max(dp[n][1], dp[n][2]));
}
int main() {
int n, A, B, C;
cin >> n;
vector<int> a, b, c;
for (int i = 0; i < n; ++i)
cin >> A >> B >> C, a.push_back(A), b.push_back(B), c.push_back(C);
cout << getMaxPoint(n, a, b, c) << endl;
}
| #include <cmath>
#include <iostream>
#include <vector>
using namespace std;
int getMaxPoint(int n, vector<int> &a, vector<int> &b, vector<int> &c) {
vector<vector<int>> dp(n + 1, vector<int>(3, 0));
int cur = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < 3; ++j) {
cur = (j == 0) ? a[i - 1] : (j == 1 ? b[i - 1] : c[i - 1]);
dp[i][j] = max(dp[i][j], max(cur + dp[i - 1][(j + 1) % 3],
cur + dp[i - 1][(j + 2) % 3]));
}
}
return max(dp[n][0], max(dp[n][1], dp[n][2]));
}
int main() {
int n, A, B, C;
cin >> n;
vector<int> a, b, c;
for (int i = 0; i < n; ++i)
cin >> A >> B >> C, a.push_back(A), b.push_back(B), c.push_back(C);
cout << getMaxPoint(n, a, b, c) << endl;
}
| [
"assignment.value.change",
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 963,396 | 963,397 | u750165355 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> A, B, C;
long long a, b, c;
for (int i = 0; i < n; i++) {
cin >> a >> b >> c;
A.push_back(a);
B.push_back(b);
C.push_back(c);
}
vector<vector<long long int>> dp(3, vector<long long int>(n, 0));
for (int i = 0; i < n; i++) {
dp[0][i] = A[i];
dp[1][i] = B[i];
dp[2][i] = C[i];
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < 3; j++) {
long long int val = INT_MIN;
for (int k = 0; k < 3; k++) {
if (k != i) {
val = max(val, dp[k][i - 1]);
}
}
dp[j][i] = dp[j][i] + val;
}
}
cout << max(dp[0][n - 1], max(dp[1][n - 1], dp[2][n - 1]));
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> A, B, C;
long long a, b, c;
for (int i = 0; i < n; i++) {
cin >> a >> b >> c;
A.push_back(a);
B.push_back(b);
C.push_back(c);
}
vector<vector<long long int>> dp(3, vector<long long int>(n, 0));
for (int i = 0; i < n; i++) {
dp[0][i] = A[i];
dp[1][i] = B[i];
dp[2][i] = C[i];
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < 3; j++) {
long long int val = INT_MIN;
for (int k = 0; k < 3; k++) {
if (k != j) {
val = max(val, dp[k][i - 1]);
}
}
dp[j][i] = dp[j][i] + val;
}
}
cout << max(dp[0][n - 1], max(dp[1][n - 1], dp[2][n - 1]));
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 963,402 | 963,403 | u922651947 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
int main() {
ll n;
cin >> n;
ll a[n][3];
for (ll i = 0; i < n; i++) {
for (ll j = 0; j < 2; j++) {
cin >> a[i][j];
}
}
ll dp[n][3] = {0};
for (ll j = 0; j < 3; j++) {
dp[0][j] = a[0][j];
}
for (ll i = 1; i < n; i++) {
dp[i][0] = a[i][0] + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = a[i][1] + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = a[i][2] + max(dp[i - 1][0], dp[i - 1][1]);
}
ll ans = max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2]));
cout << ans;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
int main() {
ll n;
cin >> n;
ll a[n][3];
for (ll i = 0; i < n; i++) {
for (ll j = 0; j < 3; j++) {
cin >> a[i][j];
}
}
ll dp[n][3] = {0};
for (ll j = 0; j < 3; j++) {
dp[0][j] = a[0][j];
}
for (ll i = 1; i < n; i++) {
dp[i][0] = a[i][0] + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = a[i][1] + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = a[i][2] + max(dp[i - 1][0], dp[i - 1][1]);
}
ll ans = max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2]));
cout << ans;
return 0;
} | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 963,425 | 963,426 | u119259666 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<vector<int>> v1(n, vector<int>(3, 0)), v2(n, vector<int>(3, 0));
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
cin >> v1[i][j];
}
}
for (int i = 1; i < n; i++) {
v1[i][0] = max(v1[i - 1][1], v1[i - 1][2]) + v1[i][0];
v1[i][1] = max(v1[i - 1][0], v1[i - 1][2]) + v1[i][1];
v1[i][2] = max(v1[i - 1][0], v1[i - 1][1]) + v1[i][2];
}
int maxi = INT_MAX;
for (int i = 0; i < 3; i++) {
maxi = max(v1[n - 1][i], maxi);
}
cout << maxi;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<vector<int>> v1(n, vector<int>(3, 0)), v2(n, vector<int>(3, 0));
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
cin >> v1[i][j];
}
}
for (int i = 1; i < n; i++) {
v1[i][0] = max(v1[i - 1][1], v1[i - 1][2]) + v1[i][0];
v1[i][1] = max(v1[i - 1][0], v1[i - 1][2]) + v1[i][1];
v1[i][2] = max(v1[i - 1][0], v1[i - 1][1]) + v1[i][2];
}
int maxi = INT_MIN;
for (int i = 0; i < 3; i++) {
maxi = max(v1[n - 1][i], maxi);
}
cout << maxi;
} | [
"variable_declaration.value.change",
"identifier.change"
] | 963,433 | 963,434 | u398129514 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define intMax 2147483647
#define rep(i, a, b) for (int i = a; i < b; i++)
#define repp(ii, aa, bb) for (int ii = aa; ii >= bb; ii--)
#define be(a) (a.begin(), a.end())
#define rbe(p) (p.rbegin(), p.rend())
#define pb push_back
vector<vector<int>> dp;
vector<int> A, B, C;
int rec(int curr, int a) {
if (curr == A.size()) {
return 0;
}
if (a > 0 && dp[curr][a] != -1) {
return dp[curr][a];
}
int ans = 0;
if (a != 1) {
ans = max(ans, A[curr] + rec(curr + 1, 1));
}
if (a != 2) {
ans = max(ans, B[curr] + rec(curr + 1, 2));
}
if (a != 3) {
ans = max(ans, C[curr] + rec(curr + 1, 3));
}
dp[curr][a] = ans;
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
dp.assign(n, vector<int>(5, -1));
A.resize(n);
B.resize(n);
C.resize(n);
rep(i, 0, n) { cin >> A[i] >> B[i] >> C[i]; }
cout << rec(0, -1);
} | #include <bits/stdc++.h>
using namespace std;
#define intMax 2147483647
#define rep(i, a, b) for (int i = a; i < b; i++)
#define repp(ii, aa, bb) for (int ii = aa; ii >= bb; ii--)
#define be(a) (a.begin(), a.end())
#define rbe(p) (p.rbegin(), p.rend())
#define pb push_back
vector<vector<int>> dp;
vector<int> A, B, C;
int rec(int curr, int a) {
if (curr == A.size()) {
return 0;
}
if (a > 0 && dp[curr][a] != -1) {
return dp[curr][a];
}
int ans = 0;
if (a != 1) {
ans = max(ans, A[curr] + rec(curr + 1, 1));
}
if (a != 2) {
ans = max(ans, B[curr] + rec(curr + 1, 2));
}
if (a != 3) {
ans = max(ans, C[curr] + rec(curr + 1, 3));
}
dp[curr][a] = ans;
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
dp.assign(n, vector<int>(4, -1));
A.resize(n);
B.resize(n);
C.resize(n);
rep(i, 0, n) { cin >> A[i] >> B[i] >> C[i]; }
cout << rec(0, 0);
} | [
"literal.number.change",
"call.arguments.change",
"io.output.change"
] | 963,435 | 963,436 | u793264122 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define intMax 2147483647
#define rep(i, a, b) for (int i = a; i < b; i++)
#define repp(ii, aa, bb) for (int ii = aa; ii >= bb; ii--)
#define be(a) (a.begin(), a.end())
#define rbe(p) (p.rbegin(), p.rend())
#define pb push_back
vector<vector<int>> dp;
vector<int> A, B, C;
int rec(int curr, int a) {
if (curr == A.size()) {
return 0;
}
if (a > 0 && dp[curr][a] != -1) {
return dp[curr][a];
}
int ans = 0;
if (a != 1) {
ans = max(ans, A[curr] + rec(curr + 1, 1));
}
if (a != 2) {
ans = max(ans, B[curr] + rec(curr + 1, 2));
}
if (a != 3) {
ans = max(ans, C[curr] + rec(curr + 1, 3));
}
dp[curr][a] = ans;
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
dp.resize(n, vector<int>(4, -1));
A.resize(n);
B.resize(n);
C.resize(n);
rep(i, 0, n) { cin >> A[i] >> B[i] >> C[i]; }
cout << rec(0, -1);
} | #include <bits/stdc++.h>
using namespace std;
#define intMax 2147483647
#define rep(i, a, b) for (int i = a; i < b; i++)
#define repp(ii, aa, bb) for (int ii = aa; ii >= bb; ii--)
#define be(a) (a.begin(), a.end())
#define rbe(p) (p.rbegin(), p.rend())
#define pb push_back
vector<vector<int>> dp;
vector<int> A, B, C;
int rec(int curr, int a) {
if (curr == A.size()) {
return 0;
}
if (a > 0 && dp[curr][a] != -1) {
return dp[curr][a];
}
int ans = 0;
if (a != 1) {
ans = max(ans, A[curr] + rec(curr + 1, 1));
}
if (a != 2) {
ans = max(ans, B[curr] + rec(curr + 1, 2));
}
if (a != 3) {
ans = max(ans, C[curr] + rec(curr + 1, 3));
}
dp[curr][a] = ans;
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
dp.assign(n, vector<int>(4, -1));
A.resize(n);
B.resize(n);
C.resize(n);
rep(i, 0, n) { cin >> A[i] >> B[i] >> C[i]; }
cout << rec(0, 0);
} | [
"call.function.change",
"literal.number.change",
"io.output.change",
"call.arguments.change"
] | 963,437 | 963,436 | u793264122 | cpp |
p03162 | #include <bits/stdc++.h>
#define db1(x) cout << #x << "=" << x << '\n'
#define db2(x, y) cout << #x << "=" << x << "," << #y << "=" << y << '\n'
#define db3(x, y, z) \
cout << #x << "=" << x << "," << #y << "=" << y << "," << #z << "=" << z \
<< '\n'
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define repA(i, a, n) for (int i = a; i <= (n); ++i)
#define repD(i, a, n) for (int i = a; i >= (n); --i)
#define rep2(j, n) for (int j = 0; j < (n); ++j)
#define F first
#define S second
#define MP make_pair
#define PB push_back
#define maximum INT_MAX
using namespace std;
using ll = long long;
using ld = long double;
const int mod = 1e9 + 7;
const long long inf = 1e11 + 5;
bool isPrime(ll n) {
for (ll i = 2; i * i <= n; ++i) {
if (n % i == 0) {
return false;
}
}
return true;
}
ll factorial(ll n) { return (n == 1 || n == 0) ? 1 : n * factorial(n - 1); }
ll power(ll x, ll y) {
ll res = 1;
x = x;
while (y > 0) {
if (y & 1)
res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
ll ncr(ll n, ll r) {
ll res = 1;
if (r > n)
return 0;
if (r > n - r)
r = n - r;
for (ll i = 0; i < r; i++) {
res *= (n - i);
res /= (i + 1);
}
return res;
}
ll gcd(ll a, ll b) {
if (a == 0)
return b;
return gcd(b % a, a);
}
ll lcm(ll a, ll b) { return (a / gcd(a, b) * b); }
ll max(ll a, ll b) {
ll ans = a > b ? a : b;
return ans;
}
ll min(ll a, ll b) {
ll ans = a < b ? a : b;
return ans;
}
// void print_set(vector<int> a)
// {
// cout<<a.size()<<"\n";
// for(auto x: a)
// {
// cout<<x<<' ';
// }
// cout<<"\n";
// }
void solve() {
ll n;
cin >> n;
vector<vector<int>> arr;
vector<int> dp(3, 0);
for (int k = 0; k < n; k++) {
vector<int> cost(3);
for (int i = 0; i < 3; i++) {
cin >> cost[i];
}
vector<int> new_dp(3, 0);
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (i != j) {
new_dp[j] = max(dp[i], dp[i] + cost[j]);
}
}
}
dp = new_dp;
}
int ans = max(dp[0], max(dp[1], dp[2]));
cout << ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
/*
void extendEuclid(int A, int B)
{
if(B==0)
{
x=1;
y=0;
}
else
{
extendEuclid(B, A%B);
int temp=x;
x=y;
y=temp-(A/B)*y;
}
}
int modularExponentiation(int X, int n, int M)
{
int result=1;
while(n>0)
{
if(n%2==1)
{
result=(x*result)%M;
}
else
{
x=x*x%M;
}
n=n/2;
return result;
}
}
int modInv(int A, int M)
{
extendEuclid(A, M)
return (x%M+M)%M;
}
int main()
{
int arr[4];
std::cin>>arr;
int A=arr[0], B=arr[1], C=arr[2], M=arr[3];
int D=modInv(C, M);
int E=modularExponentiation(A, B, M);
int ans=(D*E)%M;
std::cout<<ans;
}*/
/*int totalMultiples(int x, int a, int b, int c)
{
int un=x/a + x/b + x/c;
int in=x/lcm(a, b) + x/lcm(b, c) + x/lcm(a, c)
int fin=x/lcm(lcm(a, b), c)
int result=un-in+fin;
return result;
}
int binarySearch(vector<int> arr, int n)
{
int low=0;
int high=arr.size()-1;
while(low<high)
{
int mid=(high+low)/2;
if(arr[mid]<=n)
{
high=mid;
}
else
{
low=mid+1;
}
}
return low;
}
*/
/* Fast Factorization using Seive */
/*
int minPrime[n + 1];
for (int i = 2; i * i <= n; ++i) {
if (minPrime[i] == 0) { //If i is prime
for (int j = i * i; j <= n; j += i) {
if (minPrime[j] == 0) {
minPrime[j] = i;
}
}
}
}
for (int i = 2; i <= n; ++i) {
if (minPrime[i] == 0) {
minPrime[i] = i;
}
}
vector<int> factorize(int n) {
vector<int> res;
while (n != 1) {
res.push_back(minPrime[n]);
n /= minPrime[n];
}
return res;
}
*/ | #include <bits/stdc++.h>
#define db1(x) cout << #x << "=" << x << '\n'
#define db2(x, y) cout << #x << "=" << x << "," << #y << "=" << y << '\n'
#define db3(x, y, z) \
cout << #x << "=" << x << "," << #y << "=" << y << "," << #z << "=" << z \
<< '\n'
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define repA(i, a, n) for (int i = a; i <= (n); ++i)
#define repD(i, a, n) for (int i = a; i >= (n); --i)
#define rep2(j, n) for (int j = 0; j < (n); ++j)
#define F first
#define S second
#define MP make_pair
#define PB push_back
#define maximum INT_MAX
using namespace std;
using ll = long long;
using ld = long double;
const int mod = 1e9 + 7;
const long long inf = 1e11 + 5;
bool isPrime(ll n) {
for (ll i = 2; i * i <= n; ++i) {
if (n % i == 0) {
return false;
}
}
return true;
}
ll factorial(ll n) { return (n == 1 || n == 0) ? 1 : n * factorial(n - 1); }
ll power(ll x, ll y) {
ll res = 1;
x = x;
while (y > 0) {
if (y & 1)
res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
ll ncr(ll n, ll r) {
ll res = 1;
if (r > n)
return 0;
if (r > n - r)
r = n - r;
for (ll i = 0; i < r; i++) {
res *= (n - i);
res /= (i + 1);
}
return res;
}
ll gcd(ll a, ll b) {
if (a == 0)
return b;
return gcd(b % a, a);
}
ll lcm(ll a, ll b) { return (a / gcd(a, b) * b); }
ll max(ll a, ll b) {
ll ans = a > b ? a : b;
return ans;
}
ll min(ll a, ll b) {
ll ans = a < b ? a : b;
return ans;
}
// void print_set(vector<int> a)
// {
// cout<<a.size()<<"\n";
// for(auto x: a)
// {
// cout<<x<<' ';
// }
// cout<<"\n";
// }
void solve() {
ll n;
cin >> n;
vector<vector<int>> arr;
vector<int> dp(3, 0);
for (int k = 0; k < n; k++) {
vector<int> cost(3);
for (int i = 0; i < 3; i++) {
cin >> cost[i];
}
vector<int> new_dp(3, 0);
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] + cost[j]);
}
}
}
dp = new_dp;
}
int ans = max(dp[0], max(dp[1], dp[2]));
cout << ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
/*
void extendEuclid(int A, int B)
{
if(B==0)
{
x=1;
y=0;
}
else
{
extendEuclid(B, A%B);
int temp=x;
x=y;
y=temp-(A/B)*y;
}
}
int modularExponentiation(int X, int n, int M)
{
int result=1;
while(n>0)
{
if(n%2==1)
{
result=(x*result)%M;
}
else
{
x=x*x%M;
}
n=n/2;
return result;
}
}
int modInv(int A, int M)
{
extendEuclid(A, M)
return (x%M+M)%M;
}
int main()
{
int arr[4];
std::cin>>arr;
int A=arr[0], B=arr[1], C=arr[2], M=arr[3];
int D=modInv(C, M);
int E=modularExponentiation(A, B, M);
int ans=(D*E)%M;
std::cout<<ans;
}*/
/*int totalMultiples(int x, int a, int b, int c)
{
int un=x/a + x/b + x/c;
int in=x/lcm(a, b) + x/lcm(b, c) + x/lcm(a, c)
int fin=x/lcm(lcm(a, b), c)
int result=un-in+fin;
return result;
}
int binarySearch(vector<int> arr, int n)
{
int low=0;
int high=arr.size()-1;
while(low<high)
{
int mid=(high+low)/2;
if(arr[mid]<=n)
{
high=mid;
}
else
{
low=mid+1;
}
}
return low;
}
*/
/* Fast Factorization using Seive */
/*
int minPrime[n + 1];
for (int i = 2; i * i <= n; ++i) {
if (minPrime[i] == 0) { //If i is prime
for (int j = i * i; j <= n; j += i) {
if (minPrime[j] == 0) {
minPrime[j] = i;
}
}
}
}
for (int i = 2; i <= n; ++i) {
if (minPrime[i] == 0) {
minPrime[i] = i;
}
}
vector<int> factorize(int n) {
vector<int> res;
while (n != 1) {
res.push_back(minPrime[n]);
n /= minPrime[n];
}
return res;
}
*/ | [
"assignment.value.change",
"call.arguments.change"
] | 963,438 | 963,439 | u128189308 | cpp |
p03162 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
#define _USE_MATH_DEFINES
#include <assert.h>
#include <bitset>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stdio.h>
#include <unordered_map>
#include <unordered_set>
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define per(i, n) for (ll i = n - 1; i >= 0; --i)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define _GLIBCXX_DEBUG
using namespace std;
struct __INIT {
__INIT() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
}
} __init;
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;
}
const long long INF = 1LL << 60;
typedef long long ll;
const int mod = 1000000007;
//固定長配列の大きさ（dp用）
template <typename TYPE, size_t SIZE>
size_t array_length(const TYPE (&)[SIZE]) {
return SIZE;
}
//剰余計算
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
};
//組み合わせ(剰余付き)
// combination c(n)で初期化する必要がある。（nはCの左側の数）
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
assert(n < mod);
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
};
//桁取得
ll getDigit(ll n) {
07;
ll cnt = 0;
while (n != 0) {
n /= 10;
cnt++;
}
return cnt;
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
//ペア比較順序
typedef pair<ll, ll> pair_t;
bool PSecComp(const pair_t &a, const pair_t &b) {
if (a.second == b.second)
return a.first > b.first;
else {
return a.second > b.second;
}
}
int main() {
ll n;
cin >> n;
vector<vector<ll>> act(n, vector<ll>(3));
rep(i, n) rep(k, 3) cin >> act[i][k];
vector<vector<ll>> dp(pow(10, 6), vector<ll>(3, -INF));
rep(i, 3) dp[0][i] = act[0][i];
for (ll i = 1; i < n; i++) {
for (ll pre = 0; pre < 3; pre++) {
for (ll now = 0; now < 3; now++) {
if (pre == now)
continue;
else
chmax(dp[i][now], dp[i - 1][pre] + dp[i][now]);
}
}
}
cout << *max_element(all(dp[n - 1])) << endl;
}
| #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
#define _USE_MATH_DEFINES
#include <assert.h>
#include <bitset>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stdio.h>
#include <unordered_map>
#include <unordered_set>
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define per(i, n) for (ll i = n - 1; i >= 0; --i)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define _GLIBCXX_DEBUG
using namespace std;
struct __INIT {
__INIT() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
}
} __init;
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;
}
const long long INF = 1LL << 60;
typedef long long ll;
const int mod = 1000000007;
//固定長配列の大きさ（dp用）
template <typename TYPE, size_t SIZE>
size_t array_length(const TYPE (&)[SIZE]) {
return SIZE;
}
//剰余計算
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
};
//組み合わせ(剰余付き)
// combination c(n)で初期化する必要がある。（nはCの左側の数）
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
assert(n < mod);
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
};
//桁取得
ll getDigit(ll n) {
07;
ll cnt = 0;
while (n != 0) {
n /= 10;
cnt++;
}
return cnt;
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
//ペア比較順序
typedef pair<ll, ll> pair_t;
bool PSecComp(const pair_t &a, const pair_t &b) {
if (a.second == b.second)
return a.first > b.first;
else {
return a.second > b.second;
}
}
int main() {
ll n;
cin >> n;
vector<vector<ll>> act(n, vector<ll>(3));
rep(i, n) rep(k, 3) cin >> act[i][k];
vector<vector<ll>> dp(pow(10, 6), vector<ll>(3, -INF));
rep(i, 3) dp[0][i] = act[0][i];
for (ll i = 1; i < n; i++) {
for (ll pre = 0; pre < 3; pre++) {
for (ll now = 0; now < 3; now++) {
if (pre == now)
continue;
else
chmax(dp[i][now], dp[i - 1][pre] + act[i][now]);
}
}
}
cout << *max_element(all(dp[n - 1])) << endl;
}
| [
"call.arguments.change",
"expression.operation.binary.change"
] | 963,442 | 963,443 | u317177661 | cpp |
p03162 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
#define _USE_MATH_DEFINES
#include <assert.h>
#include <bitset>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stdio.h>
#include <unordered_map>
#include <unordered_set>
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define per(i, n) for (ll i = n - 1; i >= 0; --i)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define _GLIBCXX_DEBUG
using namespace std;
struct __INIT {
__INIT() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
}
} __init;
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;
}
const long long INF = 1LL << 60;
typedef long long ll;
const int mod = 1000000007;
//固定長配列の大きさ（dp用）
template <typename TYPE, size_t SIZE>
size_t array_length(const TYPE (&)[SIZE]) {
return SIZE;
}
//剰余計算
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
};
//組み合わせ(剰余付き)
// combination c(n)で初期化する必要がある。（nはCの左側の数）
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
assert(n < mod);
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
};
//桁取得
ll getDigit(ll n) {
07;
ll cnt = 0;
while (n != 0) {
n /= 10;
cnt++;
}
return cnt;
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
//ペア比較順序
typedef pair<ll, ll> pair_t;
bool PSecComp(const pair_t &a, const pair_t &b) {
if (a.second == b.second)
return a.first > b.first;
else {
return a.second > b.second;
}
}
int main() {
ll n;
cin >> n;
vector<vector<ll>> act(n, vector<ll>(3));
rep(i, n) rep(k, 3) cin >> act[i][k];
vector<vector<ll>> dp(pow(10, 6), vector<ll>(3, -INF));
rep(i, 3) dp[0][i] = act[0][i];
for (ll i = 0; i < n; i++) {
for (ll pre = 0; pre < 3; pre++) {
for (ll now = 0; now < 3; now++) {
if (pre == now)
continue;
else
chmax(dp[i][now], dp[i - 1][pre] + dp[i][now]);
}
}
}
cout << *max_element(all(dp[n - 1])) << endl;
}
| #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
#define _USE_MATH_DEFINES
#include <assert.h>
#include <bitset>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stdio.h>
#include <unordered_map>
#include <unordered_set>
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define per(i, n) for (ll i = n - 1; i >= 0; --i)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define _GLIBCXX_DEBUG
using namespace std;
struct __INIT {
__INIT() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
}
} __init;
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;
}
const long long INF = 1LL << 60;
typedef long long ll;
const int mod = 1000000007;
//固定長配列の大きさ（dp用）
template <typename TYPE, size_t SIZE>
size_t array_length(const TYPE (&)[SIZE]) {
return SIZE;
}
//剰余計算
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
};
//組み合わせ(剰余付き)
// combination c(n)で初期化する必要がある。（nはCの左側の数）
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
assert(n < mod);
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
};
//桁取得
ll getDigit(ll n) {
07;
ll cnt = 0;
while (n != 0) {
n /= 10;
cnt++;
}
return cnt;
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
//ペア比較順序
typedef pair<ll, ll> pair_t;
bool PSecComp(const pair_t &a, const pair_t &b) {
if (a.second == b.second)
return a.first > b.first;
else {
return a.second > b.second;
}
}
int main() {
ll n;
cin >> n;
vector<vector<ll>> act(n, vector<ll>(3));
rep(i, n) rep(k, 3) cin >> act[i][k];
vector<vector<ll>> dp(pow(10, 6), vector<ll>(3, -INF));
rep(i, 3) dp[0][i] = act[0][i];
for (ll i = 1; i < n; i++) {
for (ll pre = 0; pre < 3; pre++) {
for (ll now = 0; now < 3; now++) {
if (pre == now)
continue;
else
chmax(dp[i][now], dp[i - 1][pre] + act[i][now]);
}
}
}
cout << *max_element(all(dp[n - 1])) << endl;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"call.arguments.change",
"expression.operation.binary.change"
] | 963,444 | 963,443 | u317177661 | cpp |
p03162 | #include <bits/stdc++.h>
#pragma GCC optimize("-O3")
using namespace std;
#define ll long long
#define ld long double
#define vll vector<ll>
#define mll map<ll, ll>
#define pll pair<ll, ll>
#define ff first
#define ss second
#define pb push_back
#define deb(x) cout << #x << " : " << x << endl;
#define deb2(x, y) cout << #x << " : " << x << "\t" << #y << " : " << y << endl;
#define deb3(x, y, z) \
cout << #x << " : " << x << "\t" << #y << " : " << y << "\t" << #z << " : " \
<< z << endl;
#define deb4(w, x, y, z) \
cout << #w << " : " << w << "\t" << #x << " : " << x << "\t" << #y << " : " \
<< y << "\t" << #z << " : " << z << endl;
#define FAST \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define printv(a) \
for (ll i = 0; i < a.size(); i++) \
cout << a[i] << " ";
const int mod = 998244353.;
const int N = 1e6 + 5;
bool sortbysec(const pair<pair<ll, ll>, ll> &a,
const pair<pair<ll, ll>, ll> &b) {
return (a.second > b.second);
}
ll powermod(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;
}
bool isprime(int n) {
if (n <= 1)
return false;
if (n <= 3)
return true;
if (n % 2 == 0 || n % 3 == 0)
return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
int main() {
FAST;
ll n;
cin >> n;
vll dp(3);
for (ll i = 0; i < n; i++) {
vll c(3);
for (ll j = 0; j < 3; j++)
cin >> c[j];
vll new_dp(3, 0);
for (ll k = 0; k < 3; k++) {
for (ll l = 0; l < 3; l++) {
if (k != l) {
new_dp[l] = max(new_dp[l], new_dp[k] + c[l]);
}
}
}
dp = new_dp;
}
cout << *max_element(dp.begin(), dp.end());
return 0;
} | #include <bits/stdc++.h>
#pragma GCC optimize("-O3")
using namespace std;
#define ll long long
#define ld long double
#define vll vector<ll>
#define mll map<ll, ll>
#define pll pair<ll, ll>
#define ff first
#define ss second
#define pb push_back
#define deb(x) cout << #x << " : " << x << endl;
#define deb2(x, y) cout << #x << " : " << x << "\t" << #y << " : " << y << endl;
#define deb3(x, y, z) \
cout << #x << " : " << x << "\t" << #y << " : " << y << "\t" << #z << " : " \
<< z << endl;
#define deb4(w, x, y, z) \
cout << #w << " : " << w << "\t" << #x << " : " << x << "\t" << #y << " : " \
<< y << "\t" << #z << " : " << z << endl;
#define FAST \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define printv(a) \
for (ll i = 0; i < a.size(); i++) \
cout << a[i] << " ";
const int mod = 998244353.;
const int N = 1e6 + 5;
bool sortbysec(const pair<pair<ll, ll>, ll> &a,
const pair<pair<ll, ll>, ll> &b) {
return (a.second > b.second);
}
ll powermod(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;
}
bool isprime(int n) {
if (n <= 1)
return false;
if (n <= 3)
return true;
if (n % 2 == 0 || n % 3 == 0)
return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
int main() {
FAST;
ll n;
cin >> n;
vll dp(3);
for (ll i = 0; i < n; i++) {
vll c(3);
for (ll j = 0; j < 3; j++)
cin >> c[j];
vll new_dp(3, 0);
for (ll k = 0; k < 3; k++) {
for (ll l = 0; l < 3; l++) {
if (k != l) {
new_dp[l] = max(new_dp[l], dp[k] + c[l]);
}
}
}
dp = new_dp;
}
cout << *max_element(dp.begin(), dp.end());
return 0;
} | [
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 963,445 | 963,446 | u731601480 | cpp |
p03162 | #include <algorithm>
#include <bitset>
#include <complex>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
#define pi pair<int, int>
#define pl pair<long long, long long>
#define chmax(a, b) (a < b ? a = b : 0)
#define chmin(a, b) (a > b ? a = b : 0)
#define en cout << endl //セミコロンつけろ
//#define MM 1000000000
//#define MOD MM+7
typedef long long ll;
const int MM = 1e9;
const int MOD = 1e9 + 7;
const long double PI = acos(-1);
const long long INF = 1e15;
int dx[8] = {-1, 0, 1, 0, -1, -1, 1, 1};
int dy[8] = {0, -1, 0, 1, -1, 1, 1, -1};
// 'A' = 65, 'Z' = 90, 'a' = 97, 'z' = 122
// priority_queue<pair<int, int>, vector<pair<int, int> >, greater<pair<int,
// int> > pq;
template <typename T> //最大公約数
T GCD(T u, T v) {
return v ? GCD(v, u % v) : u;
}
template <typename T> //最小公倍数
T LCM(T x, T y) {
T gc = GCD(x, y);
return x * y / gc;
}
const int COM_MAX = 500500;
long long fac[COM_MAX], finv[COM_MAX], inv[COM_MAX];
void init() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < COM_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 nCr(int n, int k) {
if (n < k || n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
// a^n mod を計算する
long long modpow(long long a, long long n, long long MOD) {
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return res;
}
// a^{-1} mod を計算する
long long modinv(long long a, long long Mod) { return modpow(a, Mod - 2, Mod); }
bool IsPrime(int x) {
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) {
return false;
}
}
return true;
}
vector<pair<ll, ll>> PrimeFactor(ll N) {
vector<pair<ll, ll>> prime;
for (int i = 2; i * i <= N; i++) {
if (N % i != 0)
continue;
int cnt = 0;
while (N % i == 0) {
cnt++;
N /= i;
}
prime.push_back({i, cnt});
}
if (N > 1) {
prime.push_back({N, 1});
}
return prime;
}
vector<pair<ll, ll>> CountPrime(ll N) {
vector<pair<ll, ll>> prime;
for (ll i = 2; i * i <= N; i++) {
if (N % i != 0)
continue;
ll cnt = 0, n = N;
while (n % i == 0) {
cnt++;
n /= i;
}
prime.push_back({i, cnt});
}
prime.push_back({N, 1});
return prime;
}
int main() {
ll N;
cin >> N;
int dp[100010][3];
int a[100010], b[100010], c[100010];
memset(dp, 0, sizeof(dp));
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] = a[i] + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = a[i] + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = a[i] + max(dp[i - 1][0], dp[i - 1][1]);
}
cout << max(dp[N - 1][0], max(dp[N - 1][1], dp[N - 1][2])) << endl;
}
| #include <algorithm>
#include <bitset>
#include <complex>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
#define pi pair<int, int>
#define pl pair<long long, long long>
#define chmax(a, b) (a < b ? a = b : 0)
#define chmin(a, b) (a > b ? a = b : 0)
#define en cout << endl //セミコロンつけろ
//#define MM 1000000000
//#define MOD MM+7
typedef long long ll;
const int MM = 1e9;
const int MOD = 1e9 + 7;
const long double PI = acos(-1);
const long long INF = 1e15;
int dx[8] = {-1, 0, 1, 0, -1, -1, 1, 1};
int dy[8] = {0, -1, 0, 1, -1, 1, 1, -1};
// 'A' = 65, 'Z' = 90, 'a' = 97, 'z' = 122
// priority_queue<pair<int, int>, vector<pair<int, int> >, greater<pair<int,
// int> > pq;
template <typename T> //最大公約数
T GCD(T u, T v) {
return v ? GCD(v, u % v) : u;
}
template <typename T> //最小公倍数
T LCM(T x, T y) {
T gc = GCD(x, y);
return x * y / gc;
}
const int COM_MAX = 500500;
long long fac[COM_MAX], finv[COM_MAX], inv[COM_MAX];
void init() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < COM_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 nCr(int n, int k) {
if (n < k || n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
// a^n mod を計算する
long long modpow(long long a, long long n, long long MOD) {
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return res;
}
// a^{-1} mod を計算する
long long modinv(long long a, long long Mod) { return modpow(a, Mod - 2, Mod); }
bool IsPrime(int x) {
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) {
return false;
}
}
return true;
}
vector<pair<ll, ll>> PrimeFactor(ll N) {
vector<pair<ll, ll>> prime;
for (int i = 2; i * i <= N; i++) {
if (N % i != 0)
continue;
int cnt = 0;
while (N % i == 0) {
cnt++;
N /= i;
}
prime.push_back({i, cnt});
}
if (N > 1) {
prime.push_back({N, 1});
}
return prime;
}
vector<pair<ll, ll>> CountPrime(ll N) {
vector<pair<ll, ll>> prime;
for (ll i = 2; i * i <= N; i++) {
if (N % i != 0)
continue;
ll cnt = 0, n = N;
while (n % i == 0) {
cnt++;
n /= i;
}
prime.push_back({i, cnt});
}
prime.push_back({N, 1});
return prime;
}
int main() {
ll N;
cin >> N;
int dp[100010][3];
int a[100010], b[100010], c[100010];
memset(dp, 0, sizeof(dp));
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] = a[i] + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = b[i] + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = c[i] + max(dp[i - 1][0], dp[i - 1][1]);
}
cout << max(dp[N - 1][0], max(dp[N - 1][1], dp[N - 1][2])) << endl;
}
| [
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 963,449 | 963,450 | u342051078 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define MM 1000000000
#define MOD MM + 7
#define MAX 10000
#define MAP 110
#define initial_value -1
#define Pair pair<int, int>
ll INF = 1e18;
int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, -1, 0, 1};
int main() {
ll N;
cin >> N;
ll a[N], b[N], c[N];
for (ll i = 0; i < N; i++) {
cin >> a[i] >> b[i] >> c[i];
}
ll dp[100100][3];
dp[0][0] = a[0];
dp[0][1] = b[0];
dp[0][2] = c[0];
for (ll i = 0; i < N; i++) {
dp[i][0] = a[i] + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = b[i] + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = c[i] + max(dp[i - 1][0], dp[i - 1][1]);
}
ll ans = max(dp[N - 1][0], max(dp[N - 1][1], dp[N - 1][2]));
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define MM 1000000000
#define MOD MM + 7
#define MAX 10000
#define MAP 110
#define initial_value -1
#define Pair pair<int, int>
ll INF = 1e18;
int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, -1, 0, 1};
int main() {
ll N;
cin >> N;
ll a[N], b[N], c[N];
for (ll i = 0; i < N; i++) {
cin >> a[i] >> b[i] >> c[i];
}
ll dp[100100][3];
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] = a[i] + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = b[i] + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = c[i] + max(dp[i - 1][0], dp[i - 1][1]);
}
ll ans = max(dp[N - 1][0], max(dp[N - 1][1], dp[N - 1][2]));
cout << ans << endl;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 963,451 | 963,452 | u342051078 | cpp |
p03162 | #define _CRT_SECURE_NO_DEPRECATE
#include <bits/stdc++.h>
#define Rint register int
#define MP make_pair
#define fi first
#define se second
#define PB push_back
using namespace std;
typedef long long ll;
typedef pair<int, int> pii; // 注意必要时改类型
typedef vector<int> vi;
const int N = 1e5 + 5;
int n;
vi a(3);
ll dp[N][3];
void Process() {
memset(dp, 0, sizeof(dp));
cin >> n;
for (Rint i = 1; i <= n; ++i) {
for (Rint j = 0; j < 3; ++j)
cin >> a[j];
// 第一天取j
for (Rint j = 0; j < 3; ++j) {
// 第二天取k
for (Rint k = 0; k < 3; ++k) {
if (j == k)
continue;
else {
dp[i][k] = max(dp[i - 1][j] + (ll)a[k], dp[i][k]);
}
}
}
}
ll ans = -1;
for (Rint i = 0; i < 3; ++i) {
ans = max(ans, dp[n][i]);
}
cout << ans << endl;
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
#ifdef _DEBUG
int tt = clock();
freopen("in.txt", "r", stdin);
#endif
int Tcase;
cin >> Tcase;
while (Tcase--) {
Process();
}
#ifdef _DEBUG
cerr << "\nTIME = " << clock() - tt << endl;
tt = clock();
#endif
return 0;
} | #define _CRT_SECURE_NO_DEPRECATE
#include <bits/stdc++.h>
#define Rint register int
#define MP make_pair
#define fi first
#define se second
#define PB push_back
using namespace std;
typedef long long ll;
typedef pair<int, int> pii; // 注意必要时改类型
typedef vector<int> vi;
const int N = 1e5 + 5;
int n;
vi a(3);
ll dp[N][3];
void Process() {
memset(dp, 0, sizeof(dp));
cin >> n;
for (Rint i = 1; i <= n; ++i) {
for (Rint j = 0; j < 3; ++j)
cin >> a[j];
// 第一天取j
for (Rint j = 0; j < 3; ++j) {
// 第二天取k
for (Rint k = 0; k < 3; ++k) {
if (j == k)
continue;
else {
dp[i][k] = max(dp[i - 1][j] + (ll)a[k], dp[i][k]);
}
}
}
}
ll ans = -1;
for (Rint i = 0; i < 3; ++i) {
ans = max(ans, dp[n][i]);
}
cout << ans << endl;
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
#ifdef _DEBUG
int tt = clock();
freopen("in.txt", "r", stdin);
#endif
int Tcase = 1;
// cin >> Tcase;
while (Tcase--) {
Process();
}
#ifdef _DEBUG
cerr << "\nTIME = " << clock() - tt << endl;
tt = clock();
#endif
return 0;
} | [
"expression.operation.binary.remove"
] | 963,461 | 963,462 | u452819435 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100005;
const int DAYS = 3;
struct Day {
long long a, b, c;
};
int n;
long long dp[DAYS][MAX_N];
Day arr[MAX_N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%lld %lld %lld", &arr[i].a, &arr[i].b, &arr[i].c);
}
dp[0][1] = arr[1].a;
dp[1][1] = arr[1].b;
dp[1][1] = arr[1].c;
for (int i = 2; i <= n; ++i) {
for (int op = 0; op < 3; ++op) {
if (op == 0) {
dp[op][i] = arr[i].a + max(dp[1][i - 1], dp[2][i - 1]);
} else if (op == 1) {
dp[op][i] = arr[i].b + max(dp[0][i - 1], dp[2][i - 1]);
} else {
dp[op][i] = arr[i].c + max(dp[0][i - 1], dp[1][i - 1]);
}
}
}
printf("%lld", max(dp[0][n], max(dp[1][n], dp[2][n])));
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100005;
const int DAYS = 3;
struct Day {
long long a, b, c;
};
int n;
long long dp[DAYS][MAX_N];
Day arr[MAX_N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%lld %lld %lld", &arr[i].a, &arr[i].b, &arr[i].c);
}
dp[0][1] = arr[1].a;
dp[1][1] = arr[1].b;
dp[2][1] = arr[1].c;
for (int i = 2; i <= n; ++i) {
for (int op = 0; op < 3; ++op) {
if (op == 0) {
dp[op][i] = arr[i].a + max(dp[1][i - 1], dp[2][i - 1]);
} else if (op == 1) {
dp[op][i] = arr[i].b + max(dp[0][i - 1], dp[2][i - 1]);
} else {
dp[op][i] = arr[i].c + max(dp[0][i - 1], dp[1][i - 1]);
}
}
}
printf("%lld", max(dp[0][n], max(dp[1][n], dp[2][n])));
return 0;
}
| [
"literal.number.change",
"assignment.variable.change",
"variable_access.subscript.index.change"
] | 963,463 | 963,464 | u211017046 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
// Function Macros:
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define all(v) (v).begin(), (v).end()
#define setpre(n) cout << fixed << setprecision(n)
// Type / Class / Struct Definitions:
using ll = long long;
using ull = unsigned long long;
// Constants:
const int INF = (1ll << 30) - 1; // nearly 1.07e9
const ll INFLL = 1ll << 60; // nearly 1.15e18
const int MOD = 1e9 + 7;
// Global Variables:
// Prototype Declarations:
int gcd(int, int);
template <class T> inline bool chmin(T &, T);
template <class T> inline bool chmax(T &, T);
//================ Main Loop ================
int main() {
int n;
cin >> n;
int h[100100][3];
rep(i, n) {
rep(j, n) { cin >> h[i][j]; }
}
int dp[100100][3];
rep(i, 100100) {
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] + h[i][k]);
}
}
}
int ans = 0;
rep(i, 3) { chmax(ans, dp[n][i]); }
cout << ans << endl;
return 0;
}
//===========================================
// Functions:
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
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;
}
| #include <bits/stdc++.h>
using namespace std;
// Function Macros:
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define all(v) (v).begin(), (v).end()
#define setpre(n) cout << fixed << setprecision(n)
// Type / Class / Struct Definitions:
using ll = long long;
using ull = unsigned long long;
// Constants:
const int INF = (1ll << 30) - 1; // nearly 1.07e9
const ll INFLL = 1ll << 60; // nearly 1.15e18
const int MOD = 1e9 + 7;
// Global Variables:
// Prototype Declarations:
int gcd(int, int);
template <class T> inline bool chmin(T &, T);
template <class T> inline bool chmax(T &, T);
//================ Main Loop ================
int main() {
int n;
cin >> n;
int h[100100][3];
rep(i, n) {
rep(j, 3) { cin >> h[i][j]; }
}
int dp[100100][3];
rep(i, 100100) {
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] + h[i][k]);
}
}
}
int ans = 0;
rep(i, 3) { chmax(ans, dp[n][i]); }
cout << ans << endl;
return 0;
}
//===========================================
// Functions:
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
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;
}
| [] | 963,465 | 963,466 | u449175559 | cpp |
p03162 | #include <bits/stdc++.h>
#define vi vector<int>
#include <algorithm>
#include <iostream>
#include <iterator>
using namespace std;
int main() {
int n;
cin >> n;
int dp[3];
for (int d = 0; d < n; d++) {
int arr[3];
for (int i = 0; i < 3; i++)
scanf("%d", &arr[i]);
int curr[3] = {0};
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (i == j)
continue;
curr[j] = min(curr[j], dp[i] + arr[j]);
}
}
for (int z = 0; z < 3; z++) {
dp[z] = curr[z];
}
}
printf("%d", max({dp[0], dp[1], dp[2]}));
return 0;
}
| #include <bits/stdc++.h>
#define vi vector<int>
#include <algorithm>
#include <iostream>
#include <iterator>
using namespace std;
int main() {
int n;
cin >> n;
int dp[3] = {0};
for (int d = 0; d < n; d++) {
int arr[3];
for (int i = 0; i < 3; i++)
scanf("%d", &arr[i]);
int curr[3] = {0};
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (i == j)
continue;
curr[j] = max(curr[j], dp[i] + arr[j]);
}
}
for (int z = 0; z < 3; z++) {
dp[z] = curr[z];
}
}
printf("%d", max({dp[0], dp[1], dp[2]}));
return 0;
}
| [
"variable_declaration.value.change",
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 963,469 | 963,470 | u163123674 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n;
vector<int> dp(3);
for (int d = 0; d < n; ++d) {
vector<int> n_dp(3, 0);
vector<int> cst(3);
for (int x = 0; x < 3; ++x)
cin >> cst[x];
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 3; ++j) {
if (i != j)
n_dp[j] = max(n_dp[i], dp[i] + cst[j]);
}
}
dp = n_dp;
}
cout << *max_element(dp.begin(), dp.end());
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n;
vector<int> dp(3);
for (int d = 0; d < n; ++d) {
vector<int> n_dp(3, 0);
vector<int> cst(3);
for (int x = 0; x < 3; ++x)
cin >> cst[x];
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 3; ++j) {
if (i != j)
n_dp[j] = max(n_dp[j], dp[i] + cst[j]);
}
}
dp = n_dp;
}
cout << *max_element(dp.begin(), dp.end());
} | [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change"
] | 963,475 | 963,476 | u048764593 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
vector<long> a(n + 1, 0);
vector<long> b(n + 1, 0);
vector<long> c(n + 1, 0);
for (long i = 0; i < n; i++) {
long long x, y, z;
cin >> x >> y >> z;
a[i] = x;
b[i] = y;
c[i] = z;
}
for (long i = 1; i < n; i++) {
a[i] = max(b[i - 1] + a[i], c[i - 1] + a[i]);
b[i] = max(a[i - 1] + b[i], c[i - 1] + b[i]);
c[i] = max(c[i] + a[i - 1], c[i] + b[i - 1]);
}
cout << max(a[n - 1], (b[n - 1], c[n - 1])) << "\n";
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
vector<long> a(n + 1, 0);
vector<long> b(n + 1, 0);
vector<long> c(n + 1, 0);
for (long i = 0; i < n; i++) {
long long x, y, z;
cin >> x >> y >> z;
a[i] = x;
b[i] = y;
c[i] = z;
}
for (long i = 1; i < n; i++) {
a[i] = max(b[i - 1] + a[i], c[i - 1] + a[i]);
b[i] = max(a[i - 1] + b[i], c[i - 1] + b[i]);
c[i] = max(c[i] + a[i - 1], c[i] + b[i - 1]);
}
cout << max(a[n - 1], max(b[n - 1], c[n - 1])) << "\n";
} | [
"call.add",
"call.arguments.change"
] | 963,479 | 963,480 | u299510043 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
vector<long> a(n + 1, 0);
vector<long> b(n + 1, 0);
vector<long> c(n + 1, 0);
for (long i = 0; i < n; i++) {
long x, y, z;
cin >> x >> y >> z;
a[i] = x;
b[i] = y;
c[i] = z;
}
for (long i = 1; i < n; i++) {
a[i] = max(b[i - 1] + a[i], c[i - 1] + a[i]);
b[i] = max(a[i - 1] + b[i], c[i - 1] + b[i]);
c[i] = max(c[i] + a[i - 1], c[i] + b[i - 1]);
}
cout << max(a[n - 1], (b[n - 1], c[n - 1])) << "\n";
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
vector<long> a(n + 1, 0);
vector<long> b(n + 1, 0);
vector<long> c(n + 1, 0);
for (long i = 0; i < n; i++) {
long long x, y, z;
cin >> x >> y >> z;
a[i] = x;
b[i] = y;
c[i] = z;
}
for (long i = 1; i < n; i++) {
a[i] = max(b[i - 1] + a[i], c[i - 1] + a[i]);
b[i] = max(a[i - 1] + b[i], c[i - 1] + b[i]);
c[i] = max(c[i] + a[i - 1], c[i] + b[i - 1]);
}
cout << max(a[n - 1], max(b[n - 1], c[n - 1])) << "\n";
} | [
"variable_declaration.type.widen.change",
"call.add",
"call.arguments.change"
] | 963,481 | 963,480 | u299510043 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int dp[maxn][3]; // dp[i][j]±íʾѡÁËa[i][j]µÄ×ÀÖÊý
int a[maxn][3], n;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++)
cin >> a[i][j];
}
dp[0][0] = a[0][0]; //µÚ0Ðгõʼ»¯
dp[0][1] = a[0][1];
dp[0][2] = a[0][2];
for (int i = 1; i < n; i++) {
dp[i][0] += max(dp[i - 1][1], dp[i - 1][2]) + a[i][0];
dp[i][1] += max(dp[i - 1][0], dp[i - 1][2]) + a[i][1];
dp[i][2] += max(dp[i - 1][0], dp[i - 1][1]) + a[i][2];
}
cout << max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 2][2]));
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int dp[maxn][3]; // dp[i][j]±íʾѡÁËa[i][j]µÄ×ÀÖÊý
int a[maxn][3], n;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++)
cin >> a[i][j];
}
dp[0][0] = a[0][0]; //µÚ0Ðгõʼ»¯
dp[0][1] = a[0][1];
dp[0][2] = a[0][2];
for (int i = 1; i < n; i++) {
dp[i][0] += max(dp[i - 1][1], dp[i - 1][2]) + a[i][0];
dp[i][1] += max(dp[i - 1][0], dp[i - 1][2]) + a[i][1];
dp[i][2] += max(dp[i - 1][0], dp[i - 1][1]) + a[i][2];
}
cout << max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2]));
return 0;
}
| [
"literal.number.change",
"variable_access.subscript.index.change",
"io.output.change"
] | 963,486 | 963,485 | u775877429 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> ii;
typedef vector<ii> vii;
typedef vector<int> vi;
typedef vector<ll> vll;
#define PI (2 * acos(0.0))
#define eps 1e-9
#define pb push_back
#define endl "\n"
#define watch(x) cout << (#x) << " is " << (x) << endl;
#define show(v) \
for (int fi = 0; fi < v.size(); fi++) \
cout << v[fi] << " "; \
cout << endl;
#define showpair(v) \
for (int fi = 0; fi < v.size(); fi++) \
cout << v[fi].first << " " << v[fi].second << endl;
#define ff first
#define ss second
#define fu cout << "lol" << endl;
#define precision(n) cout << fixed << setprecision(n);
#define lb lower_bound
#define up upper_bound
#define vscan \
for (i = 0; i < n; i++) { \
cin >> in; \
v.pb(in); \
}
#define all(a) a.begin(), a.end()
#define min3(a, b, c) min(a, min(b, c))
#define max3(a, b, c) max(a, max(b, c))
#define mem(a, val) memset(a, val, sizeof(a))
#define loop(i, n) for (i = 0; i < n; i++)
#define TC() \
ull T; \
cin >> T; \
while (T--)
#define IN(x) \
{ scanf("%d", &x); }
#define LL(x) \
{ scanf("%lld", &x); }
#define CC(x) \
{ scanf("%c", &x); }
#define pfl(x) printf("%d\n", x)
#define pfll(x) printf("%lld\n", x)
#define newl puts("")
#define space printf(" ")
#define MOD 1000000007
#define speed \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
const int N = 1e5 + 100;
int arr[N][3];
int dp[N][3];
int main() {
int i = 0, j = 0, cs = 0, in;
int n;
cin >> n;
for (i = 0; i < n; i++)
cin >> arr[i][0] >> arr[i][1] >> arr[i][2];
dp[i][0] = arr[i][0], dp[i][1] = arr[i][1], dp[i][2] = arr[i][2];
for (i = 1; i < n; i++) {
dp[i][0] = arr[i][0] + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = arr[i][1] + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = arr[i][2] + max(dp[i - 1][1], dp[i - 1][0]);
}
cout << max3(dp[n - 1][0], dp[n - 1][1], dp[n - 1][2]) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> ii;
typedef vector<ii> vii;
typedef vector<int> vi;
typedef vector<ll> vll;
#define PI (2 * acos(0.0))
#define eps 1e-9
#define pb push_back
#define endl "\n"
#define watch(x) cout << (#x) << " is " << (x) << endl;
#define show(v) \
for (int fi = 0; fi < v.size(); fi++) \
cout << v[fi] << " "; \
cout << endl;
#define showpair(v) \
for (int fi = 0; fi < v.size(); fi++) \
cout << v[fi].first << " " << v[fi].second << endl;
#define ff first
#define ss second
#define fu cout << "lol" << endl;
#define precision(n) cout << fixed << setprecision(n);
#define lb lower_bound
#define up upper_bound
#define vscan \
for (i = 0; i < n; i++) { \
cin >> in; \
v.pb(in); \
}
#define all(a) a.begin(), a.end()
#define min3(a, b, c) min(a, min(b, c))
#define max3(a, b, c) max(a, max(b, c))
#define mem(a, val) memset(a, val, sizeof(a))
#define loop(i, n) for (i = 0; i < n; i++)
#define TC() \
ull T; \
cin >> T; \
while (T--)
#define IN(x) \
{ scanf("%d", &x); }
#define LL(x) \
{ scanf("%lld", &x); }
#define CC(x) \
{ scanf("%c", &x); }
#define pfl(x) printf("%d\n", x)
#define pfll(x) printf("%lld\n", x)
#define newl puts("")
#define space printf(" ")
#define MOD 1000000007
#define speed \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
const int N = 1e5 + 100;
int arr[N][3];
int dp[N][3];
int main() {
int i = 0, j = 0, cs = 0, in;
int n;
cin >> n;
for (i = 0; i < n; i++)
cin >> arr[i][0] >> arr[i][1] >> arr[i][2];
dp[0][0] = arr[0][0], dp[0][1] = arr[0][1], dp[0][2] = arr[0][2];
for (i = 1; i < n; i++) {
dp[i][0] = arr[i][0] + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = arr[i][1] + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = arr[i][2] + max(dp[i - 1][1], dp[i - 1][0]);
}
cout << max3(dp[n - 1][0], dp[n - 1][1], dp[n - 1][2]) << endl;
return 0;
}
| [
"assignment.variable.change",
"identifier.replace.remove",
"literal.replace.add",
"variable_access.subscript.index.change",
"assignment.value.change"
] | 963,487 | 963,488 | u992106088 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> ii;
typedef vector<ii> vii;
typedef vector<int> vi;
typedef vector<ll> vll;
#define PI (2 * acos(0.0))
#define eps 1e-9
#define pb push_back
#define endl "\n"
#define watch(x) cout << (#x) << " is " << (x) << endl;
#define show(v) \
for (int fi = 0; fi < v.size(); fi++) \
cout << v[fi] << " "; \
cout << endl;
#define showpair(v) \
for (int fi = 0; fi < v.size(); fi++) \
cout << v[fi].first << " " << v[fi].second << endl;
#define ff first
#define ss second
#define fu cout << "lol" << endl;
#define precision(n) cout << fixed << setprecision(n);
#define lb lower_bound
#define up upper_bound
#define vscan \
for (i = 0; i < n; i++) { \
cin >> in; \
v.pb(in); \
}
#define all(a) a.begin(), a.end()
#define min3(a, b, c) min(a, min(b, c))
#define max3(a, b, c) max(a, max(b, c))
#define mem(a, val) memset(a, val, sizeof(a))
#define loop(i, n) for (i = 0; i < n; i++)
#define TC() \
ull T; \
cin >> T; \
while (T--)
#define IN(x) \
{ scanf("%d", &x); }
#define LL(x) \
{ scanf("%lld", &x); }
#define CC(x) \
{ scanf("%c", &x); }
#define pfl(x) printf("%d\n", x)
#define pfll(x) printf("%lld\n", x)
#define newl puts("")
#define space printf(" ")
#define MOD 1000000007
#define speed \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
const int N = 1e5 + 100;
int arr[N][3];
int dp[N][3];
int main() {
int i = 0, j = 0, cs = 0, in;
int n;
cin >> n;
for (i = 0; i < n; i++)
cin >> arr[i][0] >> arr[i][1] >> arr[i][2];
dp[0][0] = max(arr[0][1], arr[0][2]);
dp[0][1] = max(arr[0][0], arr[0][2]);
dp[0][2] = max(arr[0][1], arr[0][0]);
for (i = 1; i < n; i++) {
dp[i][0] = max(arr[i][1] + dp[i - 1][1], arr[i][2] + dp[i - 2][2]);
dp[i][1] = max(arr[i][0] + dp[i - 1][0], arr[i][2] + dp[i - 1][2]);
dp[i][2] = max(arr[i][1] + dp[i - 1][1], arr[i][0] + dp[i - 1][0]);
}
cout << max3(dp[n - 1][0], dp[n - 1][1], dp[n - 1][2]) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> ii;
typedef vector<ii> vii;
typedef vector<int> vi;
typedef vector<ll> vll;
#define PI (2 * acos(0.0))
#define eps 1e-9
#define pb push_back
#define endl "\n"
#define watch(x) cout << (#x) << " is " << (x) << endl;
#define show(v) \
for (int fi = 0; fi < v.size(); fi++) \
cout << v[fi] << " "; \
cout << endl;
#define showpair(v) \
for (int fi = 0; fi < v.size(); fi++) \
cout << v[fi].first << " " << v[fi].second << endl;
#define ff first
#define ss second
#define fu cout << "lol" << endl;
#define precision(n) cout << fixed << setprecision(n);
#define lb lower_bound
#define up upper_bound
#define vscan \
for (i = 0; i < n; i++) { \
cin >> in; \
v.pb(in); \
}
#define all(a) a.begin(), a.end()
#define min3(a, b, c) min(a, min(b, c))
#define max3(a, b, c) max(a, max(b, c))
#define mem(a, val) memset(a, val, sizeof(a))
#define loop(i, n) for (i = 0; i < n; i++)
#define TC() \
ull T; \
cin >> T; \
while (T--)
#define IN(x) \
{ scanf("%d", &x); }
#define LL(x) \
{ scanf("%lld", &x); }
#define CC(x) \
{ scanf("%c", &x); }
#define pfl(x) printf("%d\n", x)
#define pfll(x) printf("%lld\n", x)
#define newl puts("")
#define space printf(" ")
#define MOD 1000000007
#define speed \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
const int N = 1e5 + 100;
int arr[N][3];
int dp[N][3];
int main() {
int i = 0, j = 0, cs = 0, in;
int n;
cin >> n;
for (i = 0; i < n; i++)
cin >> arr[i][0] >> arr[i][1] >> arr[i][2];
dp[0][0] = max(arr[0][1], arr[0][2]);
dp[0][1] = max(arr[0][0], arr[0][2]);
dp[0][2] = max(arr[0][1], arr[0][0]);
for (i = 1; i < n; i++) {
dp[i][0] = max(arr[i][1] + dp[i - 1][1], arr[i][2] + dp[i - 1][2]);
dp[i][1] = max(arr[i][0] + dp[i - 1][0], arr[i][2] + dp[i - 1][2]);
dp[i][2] = max(arr[i][1] + dp[i - 1][1], arr[i][0] + dp[i - 1][0]);
}
cout << max3(dp[n - 1][0], dp[n - 1][1], dp[n - 1][2]) << endl;
return 0;
}
| [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 963,489 | 963,490 | u992106088 | cpp |
p03162 | #include <bits/stdc++.h>
#define ll long long
#define ld long double
#define fi first
#define se second
#define pb push_back
#define all(v) v.begin(), v.end()
#define repf(i, a, b) for (ll i = a; i < b; i++)
#define repb(i, a, b) for (ll i = a; i >= b; i--)
#define IOS \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define mod 1000000007
#define MOD 998244353
using namespace std;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
ll power(ll a, ll n, ll m) {
ll ans = 1;
while (n) {
if (n & 1)
ans = (ans * a) % m;
n >>= 1;
a = (a * a) % m;
}
return ans;
}
ll invmod(ll a, ll m) { return power(a, m - 2, m); }
int main() {
int n, k, i;
cin >> n;
int dp1[n + 1] = {}, dp2[n + 1] = {}, dp3[n + 1] = {};
for (i = 1; i <= n; i++) {
int a, b, c;
cin >> a >> b >> c;
dp1[i] = a + max(dp2[i - 1], dp2[i - 1]);
dp2[i] = b + max(dp1[i - 1], dp3[i - 1]);
dp3[i] = c + max(dp1[i - 1], dp2[i - 1]);
}
cout << max(dp1[n], max(dp2[n], dp3[n]));
} | #include <bits/stdc++.h>
#define ll long long
#define ld long double
#define fi first
#define se second
#define pb push_back
#define all(v) v.begin(), v.end()
#define repf(i, a, b) for (ll i = a; i < b; i++)
#define repb(i, a, b) for (ll i = a; i >= b; i--)
#define IOS \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define mod 1000000007
#define MOD 998244353
using namespace std;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
ll power(ll a, ll n, ll m) {
ll ans = 1;
while (n) {
if (n & 1)
ans = (ans * a) % m;
n >>= 1;
a = (a * a) % m;
}
return ans;
}
ll invmod(ll a, ll m) { return power(a, m - 2, m); }
int main() {
int n, k, i;
cin >> n;
int dp1[n + 1] = {}, dp2[n + 1] = {}, dp3[n + 1] = {};
for (i = 1; i <= n; i++) {
int a, b, c;
cin >> a >> b >> c;
dp1[i] = a + max(dp2[i - 1], dp3[i - 1]);
dp2[i] = b + max(dp1[i - 1], dp3[i - 1]);
dp3[i] = c + max(dp1[i - 1], dp2[i - 1]);
}
cout << max(dp1[n], max(dp2[n], dp3[n]));
} | [
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 963,499 | 963,500 | u834480753 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
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 ans[n][3];
ans[0][0] = arr[0][0];
ans[0][1] = arr[0][1];
ans[0][2] = arr[0][2];
for (int i = 1; i < n; i++) {
ans[i][0] = arr[i][0] + max(ans[i - 1][1], ans[i - 1][2]);
ans[i][1] = arr[i][1] + max(ans[i - 1][0], ans[i - 1][2]);
ans[i][2] = arr[i][2] + max(ans[i - 1][0], ans[i - 1][1]);
}
int k = max(ans[n - 1][0], max(ans[n - 1][1], ans[n - 1][2]));
cout << k - 1;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
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 ans[n][3];
ans[0][0] = arr[0][0];
ans[0][1] = arr[0][1];
ans[0][2] = arr[0][2];
for (int i = 1; i < n; i++) {
ans[i][0] = arr[i][0] + max(ans[i - 1][1], ans[i - 1][2]);
ans[i][1] = arr[i][1] + max(ans[i - 1][0], ans[i - 1][2]);
ans[i][2] = arr[i][2] + max(ans[i - 1][0], ans[i - 1][1]);
}
int k = max(ans[n - 1][0], max(ans[n - 1][1], ans[n - 1][2]));
cout << k;
return 0;
}
| [
"expression.operation.binary.remove"
] | 963,501 | 963,502 | u847978334 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int val[N][3];
for (int i = 0; i < N; i++) {
for (int j = 0; j < 3; j++) {
cin >> val[i][j];
}
}
long long int dp[N][N];
for (int i = 0; i < N; i++) {
for (int j = 0; j < 3; j++) {
dp[i][j] = -100000;
}
}
for (int i = 0; i < 3; i++) {
dp[0][i] = val[0][i];
}
for (int i = 1; i < N; i++) {
for (int j = 0; j < 3; j++) {
dp[i][j] = max(dp[i - 1][(j + 1) % 3] + val[i][j],
dp[i - 1][(j + 2) % 3] + val[i][j]);
}
}
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;
int main() {
int N;
cin >> N;
int val[N][3];
for (int i = 0; i < N; i++) {
for (int j = 0; j < 3; j++) {
cin >> val[i][j];
}
}
long long int dp[N][3];
for (int i = 0; i < N; i++) {
for (int j = 0; j < 3; j++) {
dp[i][j] = -100000;
}
}
for (int i = 0; i < 3; i++) {
dp[0][i] = val[0][i];
}
for (int i = 1; i < N; i++) {
for (int j = 0; j < 3; j++) {
dp[i][j] = max(dp[i - 1][(j + 1) % 3] + val[i][j],
dp[i - 1][(j + 2) % 3] + val[i][j]);
}
}
cout << max(dp[N - 1][0], max(dp[N - 1][1], dp[N - 1][2])) << endl;
return 0;
} | [
"identifier.replace.remove",
"literal.replace.add",
"variable_declaration.array_dimensions.change"
] | 963,505 | 963,506 | u384300282 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
template <typename A, typename B> string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N> string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A> string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B> string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> dp(3);
for (int day = 0; day < n; day++) {
vector<int> c(3);
vector<int> new_dp(3, 0);
for (int 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], dp[2], dp[3]}) << "\n";
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
template <typename A, typename B> string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N> string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A> string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B> string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> dp(3);
for (int day = 0; day < n; day++) {
vector<int> c(3);
vector<int> new_dp(3, 0);
for (int 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], dp[1], dp[2]}) << "\n";
return 0;
}
| [
"literal.number.change",
"variable_access.subscript.index.change",
"io.output.change"
] | 963,510 | 963,511 | u872885167 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define mp make_pair
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
#ifndef ONLINE_JUDGE
// for getting input from input.txt
freopen("input.txt", "r+", stdin);
// for writing output to output.txt
freopen("output.txt", "w+", stdout);
#endif
int n;
cin >> n;
int dp[4], a[4], t[4];
cin >> dp[1] >> dp[2] >> dp[3];
for (int i = 1; i < n; i++) {
cin >> a[1] >> a[2] >> a[3];
t[1] = t[2] = t[3] = 0;
for (int j = 1; j <= 3; j++) {
for (int k = 1; k <= 3; k++) {
if (j == k)
continue;
t[k] = max(t[k], dp[k] + a[j]);
}
}
dp[1] = t[1];
dp[2] = t[2];
dp[3] = t[3];
// cout << dp[1] << " " << dp[2] << " " << dp[3] << '\n';
}
cout << max(dp[1], max(dp[2], dp[3])) << '\n';
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define mp make_pair
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
#ifdef ONLINE_JUDGE
// for getting input from input.txt
freopen("input.txt", "r+", stdin);
// for writing output to output.txt
freopen("output.txt", "w+", stdout);
#endif
int n;
cin >> n;
int dp[4], a[4], t[4];
cin >> dp[1] >> dp[2] >> dp[3];
for (int i = 1; i < n; i++) {
cin >> a[1] >> a[2] >> a[3];
t[1] = t[2] = t[3] = 0;
for (int j = 1; j <= 3; j++) {
for (int k = 1; k <= 3; k++) {
if (j == k)
continue;
t[j] = max(t[j], dp[k] + a[j]);
}
}
dp[1] = t[1];
dp[2] = t[2];
dp[3] = t[3];
// cout << dp[1] << " " << dp[2] << " " << dp[3] << '\n';
}
cout << max(dp[1], max(dp[2], dp[3])) << '\n';
} | [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change",
"assignment.value.change",
"call.arguments.change"
] | 963,512 | 963,513 | u368645110 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int dp[100001][3], arr[100001][3], N, maxe = INT_MIN;
void solve() {
int lasteve = -1, lindex = -1;
dp[0][0] = arr[0][0];
dp[0][1] = arr[0][1];
dp[0][2] = arr[0][2];
maxe = max(dp[0][0], max(dp[0][1], dp[0][2]));
for (int i = 1; i < N; i++) {
for (int j = 0; j < 3; j++) {
// if(i==1)
//{
for (int k = 0; k < 3; k++) {
if (k == j)
continue;
else {
dp[i][j] = max(dp[i - 1][k] + arr[i][j], dp[i][j]);
if (dp[i][j] > maxe) {
maxe = dp[i][j];
lasteve = j;
}
}
}
/*}
else
{
if(j!=lasteve)
{
dp[i][j] = max(dp[i-1][lasteve]+arr[i][j],dp[i][j]);
//cout << dp[i][j] << " ";
if(dp[i][j] > maxe){maxe = dp[i][j]; lindex=j;}
}
}*/
}
// if(i!=1)lasteve = lindex;
// cout << lasteve << " " << maxe << endl;
}
}
void printarr() {
for (int i = 0; i < N; i++)
for (int j = 0; j < 3; j++)
cout << arr[i][j] << " ";
cout << endl;
}
void printdparr() {
for (int i = 0; i < N; i++) {
for (int j = 0; j < 3; j++) {
cout << dp[i][j] << " ";
}
cout << endl;
}
}
int main() {
// your code goes here
memset(dp, -1, sizeof(dp));
cin >> N;
for (int i = 0; i < N; i++) {
for (int j = 0; j < 3; j++) {
cin >> arr[i][j];
}
}
// printarr();
solve();
printdparr();
cout << maxe << endl;
return 0;
}
/*
3
10 15 20
5 10 20
10 7 6
7
6 7 8
8 8 3
5 2 2
7 8 6
4 6 8
2 3 4
7 5 1
*/
| #include <bits/stdc++.h>
using namespace std;
int dp[100001][3], arr[100001][3], N, maxe = INT_MIN;
void solve() {
int lasteve = -1, lindex = -1;
dp[0][0] = arr[0][0];
dp[0][1] = arr[0][1];
dp[0][2] = arr[0][2];
maxe = max(dp[0][0], max(dp[0][1], dp[0][2]));
for (int i = 1; i < N; i++) {
for (int j = 0; j < 3; j++) {
// if(i==1)
//{
for (int k = 0; k < 3; k++) {
if (k == j)
continue;
else {
dp[i][j] = max(dp[i - 1][k] + arr[i][j], dp[i][j]);
if (dp[i][j] > maxe) {
maxe = dp[i][j];
lasteve = j;
}
}
}
/*}
else
{
if(j!=lasteve)
{
dp[i][j] = max(dp[i-1][lasteve]+arr[i][j],dp[i][j]);
//cout << dp[i][j] << " ";
if(dp[i][j] > maxe){maxe = dp[i][j]; lindex=j;}
}
}*/
}
// if(i!=1)lasteve = lindex;
// cout << lasteve << " " << maxe << endl;
}
}
void printarr() {
for (int i = 0; i < N; i++)
for (int j = 0; j < 3; j++)
cout << arr[i][j] << " ";
cout << endl;
}
void printdparr() {
for (int i = 0; i < N; i++) {
for (int j = 0; j < 3; j++) {
cout << dp[i][j] << " ";
}
cout << endl;
}
}
int main() {
// your code goes here
memset(dp, -1, sizeof(dp));
cin >> N;
for (int i = 0; i < N; i++) {
for (int j = 0; j < 3; j++) {
cin >> arr[i][j];
}
}
// printarr();
solve();
// printdparr();
cout << maxe << endl;
return 0;
}
/*
3
10 15 20
5 10 20
10 7 6
7
6 7 8
8 8 3
5 2 2
7 8 6
4 6 8
2 3 4
7 5 1
*/
| [
"call.remove"
] | 963,517 | 963,518 | u396829767 | cpp |
p03162 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
const int INT_INF = 2147483647;
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;
}
typedef pair<int, int> P;
int dp[100005][3];
int main() {
int n;
cin >> n;
int h[n + 1][3];
rep(i, n) cin >> h[i + 1][0] >> h[i + 1][1] >> h[i + 1][2];
for (int d = 1; d <= n; d++) {
rep(i, 3) {
rep(j, 3) {
if (i == j)
continue;
chmax(dp[d][i], dp[d - 1][j] + h[d][i]);
}
}
}
int ans = 0;
rep(i, n) chmax(ans, dp[n][i]);
cout << ans << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
const int INT_INF = 2147483647;
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;
}
typedef pair<int, int> P;
int dp[100005][3];
int main() {
int n;
cin >> n;
int h[n + 1][3];
rep(i, n) cin >> h[i + 1][0] >> h[i + 1][1] >> h[i + 1][2];
for (int d = 1; d <= n; d++) {
rep(i, 3) {
rep(j, 3) {
if (i == j)
continue;
chmax(dp[d][i], dp[d - 1][j] + h[d][i]);
}
}
}
int ans = 0;
rep(i, 3) chmax(ans, dp[n][i]);
cout << ans << endl;
} | [
"identifier.replace.remove",
"literal.replace.add",
"call.arguments.change"
] | 963,527 | 963,528 | u639032323 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> ii;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
int a[n], b[n], c[n];
for (int i = 0; i < n; ++i) {
cin >> a[i] >> b[i] >> c[i];
}
int ma = a[0], mb = b[0], mc = c[0];
for (int i = 1; i < n; ++i) {
int na = max(mb, mc) + a[i];
int nb = max(ma, mb) + b[i];
int nc = max(mb, ma) + c[i];
ma = na, mb = nb, mc = nc;
}
cout << max(max(ma, mb), mc) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> ii;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
int a[n], b[n], c[n];
for (int i = 0; i < n; ++i) {
cin >> a[i] >> b[i] >> c[i];
}
int ma = a[0], mb = b[0], mc = c[0];
for (int i = 1; i < n; ++i) {
int na = max(mb, mc) + a[i];
int nb = max(ma, mc) + b[i];
int nc = max(mb, ma) + c[i];
ma = na, mb = nb, mc = nc;
}
cout << max(max(ma, mb), mc) << endl;
return 0;
}
| [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 963,529 | 963,530 | u063318293 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define si size()
#define bk back()
#define popb pop_back()
#define fastio \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL)
#define endl "\n"
#define lb lower_bound
#define ub upper_bound
#define emp empty()
#define beg begin()
#define en end()
#define ump unordered_map
#define forl(i, a, n) for (int i = a; i < n; i++)
#define rfor(i, n, a) for (int i = n; i >= a; i--)
#define fore(i, a, n) for (int i = a; i <= n; i++)
#define len length()
#define N 200000
int main() {
int n, k;
cin >> n;
int arr[n][3];
forl(i, 0, n) forl(j, 0, 3) cin >> arr[i][j];
int dp[n][3];
forl(i, 1, n) forl(j, 1, 3) dp[i][j] = -1;
dp[0][0] = arr[0][0];
dp[0][1] = arr[0][1];
dp[0][2] = arr[0][2];
forl(i, 1, n) {
forl(j, 0, 3) {
forl(k, 0, 3) {
if (k != j) {
dp[i][j] = max(dp[i][j], arr[i][j] + dp[i - 1][k]);
}
}
}
}
cout << max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2])) << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define si size()
#define bk back()
#define popb pop_back()
#define fastio \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL)
#define endl "\n"
#define lb lower_bound
#define ub upper_bound
#define emp empty()
#define beg begin()
#define en end()
#define ump unordered_map
#define forl(i, a, n) for (int i = a; i < n; i++)
#define rfor(i, n, a) for (int i = n; i >= a; i--)
#define fore(i, a, n) for (int i = a; i <= n; i++)
#define len length()
#define N 200000
int main() {
int n, k;
cin >> n;
int arr[n][3];
forl(i, 0, n) forl(j, 0, 3) cin >> arr[i][j];
int dp[n][3];
forl(i, 1, n) forl(j, 0, 3) dp[i][j] = -1;
dp[0][0] = arr[0][0];
dp[0][1] = arr[0][1];
dp[0][2] = arr[0][2];
forl(i, 1, n) {
forl(j, 0, 3) {
forl(k, 0, 3) {
if (k != j) {
dp[i][j] = max(dp[i][j], arr[i][j] + dp[i - 1][k]);
}
}
}
}
cout << max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2])) << endl;
} | [
"literal.number.change",
"assignment.variable.change",
"call.arguments.change"
] | 963,533 | 963,534 | u397955542 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define ll unsigned long long
#define INF 1234567890
#define N (int)(1e5 + 5)
#define pi acos(-1)
void solve() {
int dp[4];
int n;
cin >> n;
for (int i = 1; i <= 3; ++i)
cin >> dp[i];
for (int i = 2; i <= n; ++i) {
int cost[4], new_dp[4];
for (int j = 1; j <= 3; ++j)
cin >> cost[j], new_dp[j] = -INF;
for (int j = 1; j <= 3; ++j)
for (int k = 1; k <= 3; ++k)
if (j != k)
new_dp[j] = max(new_dp[j], cost[j] + dp[i]);
for (int j = 1; j <= 3; ++j)
dp[j] = new_dp[j];
}
cout << max(dp[1], max(dp[2], dp[3]));
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll unsigned long long
#define INF 1234567890
#define N (int)(1e5 + 5)
#define pi acos(-1)
void solve() {
int dp[4];
int n;
cin >> n;
for (int i = 1; i <= 3; ++i)
cin >> dp[i];
for (int i = 2; i <= n; ++i) {
int cost[4], new_dp[4];
for (int j = 1; j <= 3; ++j)
cin >> cost[j], new_dp[j] = -INF;
for (int j = 1; j <= 3; ++j)
for (int k = 1; k <= 3; ++k)
if (j != k)
new_dp[j] = max(new_dp[j], cost[j] + dp[k]);
for (int j = 1; j <= 3; ++j)
dp[j] = new_dp[j];
}
cout << max(dp[1], max(dp[2], dp[3]));
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
}
| [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 963,537 | 963,538 | u592548368 | cpp |
p03162 | #include <bits/stdc++.h>
#define ALL(v) v.begin(), v.end()
#define MOD 1000000007
#define MAX 510000
#define Rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rep(i, n) for (ll i = 1; i <= (ll)(n); i++)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
// cout << fixed << setprecision(10);//
//最小公倍数//
ll gcd(ll x, ll y) {
if (x == 0)
return y;
return gcd(y % x, x);
}
ll lcm(ll x, ll y) { return x * y / gcd(x, y); }
//べき//
ll squ(ll n, ll p, ll m) {
if (p == 0)
return 1;
if (p % 2 == 0) {
ll t = squ(n, p / 2, m);
return t * t % m;
}
return n * squ(n, p - 1, m);
}
//逆元mod(mを法とするaの逆元)//
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
// Cmonp//
ll 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;
}
}
// 二項係数計算
ll 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;
}
// nが大
ll com(ll n, ll m) {
if (n <= 0 || m <= 0 || n == m) {
return 1;
}
if (n < m) {
return 0;
}
ll k = 1;
for (ll i = 1; i <= m; i++) {
k *= (n - i + 1);
k %= MOD;
k *= modinv(i, MOD);
k %= MOD;
}
return k;
}
//
////////////////////////////////////////////////////////////////////
int main() {
ll n;
cin >> n;
ll a[n + 1][3];
rep(i, n) {
Rep(j, 3) { cin >> a[i][j]; }
}
ll dp[n + 1][3];
Rep(i, n + 1) {
Rep(j, 3) { dp[i][j] = 0; }
}
rep(i, 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][1], dp[i - 1][0]);
}
ll ans = (dp[n][1], max(dp[n][2], dp[n][0]));
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define ALL(v) v.begin(), v.end()
#define MOD 1000000007
#define MAX 510000
#define Rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rep(i, n) for (ll i = 1; i <= (ll)(n); i++)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
// cout << fixed << setprecision(10);//
//最小公倍数//
ll gcd(ll x, ll y) {
if (x == 0)
return y;
return gcd(y % x, x);
}
ll lcm(ll x, ll y) { return x * y / gcd(x, y); }
//べき//
ll squ(ll n, ll p, ll m) {
if (p == 0)
return 1;
if (p % 2 == 0) {
ll t = squ(n, p / 2, m);
return t * t % m;
}
return n * squ(n, p - 1, m);
}
//逆元mod(mを法とするaの逆元)//
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
// Cmonp//
ll 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;
}
}
// 二項係数計算
ll 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;
}
// nが大
ll com(ll n, ll m) {
if (n <= 0 || m <= 0 || n == m) {
return 1;
}
if (n < m) {
return 0;
}
ll k = 1;
for (ll i = 1; i <= m; i++) {
k *= (n - i + 1);
k %= MOD;
k *= modinv(i, MOD);
k %= MOD;
}
return k;
}
//
////////////////////////////////////////////////////////////////////
int main() {
ll n;
cin >> n;
ll a[n + 1][3];
rep(i, n) {
Rep(j, 3) { cin >> a[i][j]; }
}
ll dp[n + 1][3];
Rep(i, n + 1) {
Rep(j, 3) { dp[i][j] = 0; }
}
rep(i, 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][1], dp[i - 1][0]);
}
ll ans = max(dp[n][1], max(dp[n][2], dp[n][0]));
cout << ans << endl;
return 0;
}
| [
"call.add"
] | 963,542 | 963,543 | u233626335 | cpp |
p03162 | #include <bits/stdc++.h>
#define ALL(v) v.begin(), v.end()
#define MOD 1000000007
#define MAX 510000
#define Rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rep(i, n) for (ll i = 1; i <= (ll)(n); i++)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
// cout << fixed << setprecision(10);//
//最小公倍数//
ll gcd(ll x, ll y) {
if (x == 0)
return y;
return gcd(y % x, x);
}
ll lcm(ll x, ll y) { return x * y / gcd(x, y); }
//べき//
ll squ(ll n, ll p, ll m) {
if (p == 0)
return 1;
if (p % 2 == 0) {
ll t = squ(n, p / 2, m);
return t * t % m;
}
return n * squ(n, p - 1, m);
}
//逆元mod(mを法とするaの逆元)//
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
// Cmonp//
ll 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;
}
}
// 二項係数計算
ll 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;
}
// nが大
ll com(ll n, ll m) {
if (n <= 0 || m <= 0 || n == m) {
return 1;
}
if (n < m) {
return 0;
}
ll k = 1;
for (ll i = 1; i <= m; i++) {
k *= (n - i + 1);
k %= MOD;
k *= modinv(i, MOD);
k %= MOD;
}
return k;
}
//
////////////////////////////////////////////////////////////////////
int main() {
ll n;
cin >> n;
ll a[n + 1][3];
rep(i, n) {
Rep(j, 3) { cin >> a[i][j]; }
}
ll dp[n + 1][3];
Rep(i, n + 1) {
Rep(j, 3) { dp[i][j] = 0; }
}
rep(i, 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][1], dp[i - 1][0]);
}
ll ans = (dp[n][1], max(dp[n][2], dp[n][0]));
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define ALL(v) v.begin(), v.end()
#define MOD 1000000007
#define MAX 510000
#define Rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rep(i, n) for (ll i = 1; i <= (ll)(n); i++)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
// cout << fixed << setprecision(10);//
//最小公倍数//
ll gcd(ll x, ll y) {
if (x == 0)
return y;
return gcd(y % x, x);
}
ll lcm(ll x, ll y) { return x * y / gcd(x, y); }
//べき//
ll squ(ll n, ll p, ll m) {
if (p == 0)
return 1;
if (p % 2 == 0) {
ll t = squ(n, p / 2, m);
return t * t % m;
}
return n * squ(n, p - 1, m);
}
//逆元mod(mを法とするaの逆元)//
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
// Cmonp//
ll 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;
}
}
// 二項係数計算
ll 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;
}
// nが大
ll com(ll n, ll m) {
if (n <= 0 || m <= 0 || n == m) {
return 1;
}
if (n < m) {
return 0;
}
ll k = 1;
for (ll i = 1; i <= m; i++) {
k *= (n - i + 1);
k %= MOD;
k *= modinv(i, MOD);
k %= MOD;
}
return k;
}
//
////////////////////////////////////////////////////////////////////
int main() {
ll n;
cin >> n;
ll a[n + 1][3];
rep(i, n) {
Rep(j, 3) { cin >> a[i][j]; }
}
ll dp[n + 1][3];
Rep(i, n + 1) {
Rep(j, 3) { dp[i][j] = 0; }
}
rep(i, 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][1], dp[i - 1][0]);
}
ll ans = max(dp[n][1], max(dp[n][2], dp[n][0]));
cout << ans << endl;
return 0;
}
| [
"assignment.value.change",
"call.add"
] | 963,544 | 963,543 | u233626335 | cpp |
p03162 | #include <bits/stdc++.h>
#define int long long
using namespace std;
const int N = 1e5 + 1;
const int MX = 1e15 + 123456789;
int n;
int a[N][4];
int dp[N][4];
int solve(int i, int j) {
if (i == 1)
return a[i][j];
if (dp[i][j] + 1) {
return dp[i][j];
}
int path, mx = 0;
for (int u = 1; u <= 3; u++) {
if (u == j)
continue;
path = solve(i - 1, u) + a[i][u];
mx = max(mx, path);
}
return dp[i][j] = mx;
}
main() {
scanf("%lld", &n);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= 3; j++) {
scanf("%lld", &a[i][j]);
}
}
memset(dp, -1, sizeof(dp));
int ans = 0;
int mx = 0;
for (int i = 1; i <= 3; i++) {
mx = max(solve(n, i), mx);
}
cout << mx;
}
| #include <bits/stdc++.h>
#define int long long
using namespace std;
const int N = 1e5 + 1;
const int MX = 1e15 + 123456789;
int n;
int a[N][4];
int dp[N][4];
int solve(int i, int j) {
if (i == 1)
return a[i][j];
if (dp[i][j] + 1) {
return dp[i][j];
}
int path, mx = 0;
for (int u = 1; u <= 3; u++) {
if (u == j)
continue;
path = solve(i - 1, u) + a[i][j];
mx = max(mx, path);
}
return dp[i][j] = mx;
}
main() {
scanf("%lld", &n);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= 3; j++) {
scanf("%lld", &a[i][j]);
}
}
memset(dp, -1, sizeof(dp));
int ans = 0;
int mx = 0;
for (int i = 1; i <= 3; i++) {
mx = max(solve(n, i), mx);
}
cout << mx;
}
| [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 963,545 | 963,546 | u903920392 | cpp |
p03162 | #include <bits/stdc++.h>
#include <cstdlib>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
const int INF = 1e9 + 5;
int main() {
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;
}
cout << min({dp[0], dp[1], dp[2]});
return 0;
}
| #include <bits/stdc++.h>
#include <cstdlib>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
const int INF = 1e9 + 5;
int main() {
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;
}
cout << max({dp[0], dp[1], dp[2]});
return 0;
}
| [
"misc.opposites",
"identifier.change",
"call.function.change",
"io.output.change"
] | 963,547 | 963,548 | u895395057 | cpp |
p03162 | /****************************************************
* Template for coding contests *
* Author : Sanjeev Sharma *
* Email : thedevelopersanjeev@gmail.com *
*****************************************************/
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("no-stack-protector,fast-math")
#pragma GCC target("sse4")
#pragma comment(linker, "/stack:200000000")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define deb(x) cout << #x << " is " << x << "\n";
using namespace std;
using namespace __gnu_pbds;
const double PI = 2 * acos(0.0);
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
vector<long long> ans(3, 0);
for (long long i = 0; i < n; i++) {
vector<long long> curr(3);
vector<long long> dp(3, 0);
for (long long i = 0; i < 3; i++)
cin >> curr[i];
for (long long i = 0; i < 3; i++) {
for (long long j = 0; j < 3; j++) {
if (i != j) {
dp[j] = max(dp[j], dp[i] + curr[j]);
}
}
}
ans = dp;
}
cout << max({ans[0], ans[1], ans[2]});
return 0;
}
| /****************************************************
* Template for coding contests *
* Author : Sanjeev Sharma *
* Email : thedevelopersanjeev@gmail.com *
*****************************************************/
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("no-stack-protector,fast-math")
#pragma GCC target("sse4")
#pragma comment(linker, "/stack:200000000")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define deb(x) cout << #x << " is " << x << "\n";
using namespace std;
using namespace __gnu_pbds;
const double PI = 2 * acos(0.0);
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
vector<long long> ans(3, 0);
for (long long i = 0; i < n; i++) {
vector<long long> curr(3);
vector<long long> dp(3, 0);
for (long long i = 0; i < 3; i++)
cin >> curr[i];
for (long long i = 0; i < 3; i++) {
for (long long j = 0; j < 3; j++) {
if (i != j) {
dp[j] = max(dp[j], ans[i] + curr[j]);
}
}
}
ans = dp;
}
cout << max({ans[0], ans[1], ans[2]});
return 0;
}
| [
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 963,551 | 963,552 | u752949890 | cpp |
p03162 | #include <bits/stdc++.h>
#include <iostream>
#include <vector>
using namespace std;
#define pb push_back
#define ll long long
#define ae addEdge
#define mp make_pair
#define vi vector<int>
#define vll vector<long long>
#define si set<int>
#define vvi vector<vector<int>>
#define pii pair<int, int>
#define sortv sort(v.begin(), v.end())
#define sorta sort(a.begin(), a.end())
#define sortb sort(b.begin(), b.end())
#define sorts sort(s.begin(), s.end())
int main() {
int n;
cin >> n;
int v[n][3];
int a, b, c;
for (int i = 0; i < n; i++) {
// cin>>a>>b>>c;
cin >> v[i][0] >> v[i][1] >> v[i][2];
}
int dp[n][3];
dp[0][0] = v[0][0];
dp[0][1] = v[0][1];
dp[0][2] = v[0][2];
for (int i = 1; i < n; i++) {
dp[i][0] = max(dp[i - 1][1] + v[i][1], dp[i - 1][2] + v[i][2]);
dp[i][1] = max(dp[i - 1][0] + v[i][0], dp[i - 1][2] + v[i][2]);
dp[i][2] = max(dp[i - 1][1] + v[i][1], dp[i - 1][0] + v[i][0]);
}
cout << max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2])) << endl;
} | #include <bits/stdc++.h>
#include <iostream>
#include <vector>
using namespace std;
#define pb push_back
#define ll long long
#define ae addEdge
#define mp make_pair
#define vi vector<int>
#define vll vector<long long>
#define si set<int>
#define vvi vector<vector<int>>
#define pii pair<int, int>
#define sortv sort(v.begin(), v.end())
#define sorta sort(a.begin(), a.end())
#define sortb sort(b.begin(), b.end())
#define sorts sort(s.begin(), s.end())
int main() {
int n;
cin >> n;
int v[n][3];
int a, b, c;
for (int i = 0; i < n; i++) {
// cin>>a>>b>>c;
cin >> v[i][0] >> v[i][1] >> v[i][2];
}
int dp[n][3];
dp[0][0] = v[0][0];
dp[0][1] = v[0][1];
dp[0][2] = v[0][2];
for (int i = 1; i < n; i++) {
dp[i][0] = max(dp[i - 1][1] + v[i][0], dp[i - 1][2] + v[i][0]);
dp[i][1] = max(dp[i - 1][0] + v[i][1], dp[i - 1][2] + v[i][1]);
dp[i][2] = max(dp[i - 1][1] + v[i][2], dp[i - 1][0] + v[i][2]);
}
cout << max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2])) << endl;
} | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 963,553 | 963,554 | u583798468 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const ll mod = 1e9 + 7;
#define rep(i, a, b) for (ll i = a; i < b; i++)
void swap(ll &a, ll &b) {
ll t = a;
a = b;
b = t;
}
ll min(ll a, ll b) {
if (a < b)
return a;
return b;
}
ll max(ll a, ll b) {
if (a > b)
return a;
return b;
}
ll pow(ll a, ll b) {
a %= mod;
ll ans = 1;
while (b > 0) {
if (b & 1)
ans = ans * a % mod;
a = a * a % mod;
b /= 2;
}
return ans;
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
/// 1 2 3 4 ....
ll n;
cin >> n;
ll a[n][3];
for (int i = 0; i < n; i++) {
cin >> a[i][0] >> a[i][1] >> a[i][2];
}
ll dp[3][3];
dp[0][0] = a[0][0];
dp[0][1] = a[0][1];
dp[0][2] = a[0][2];
for (int i = 1; i < n; i++) {
dp[i][0] = max(dp[i - 1][1] + a[i][0], dp[i - 1][2] + a[i][0]);
dp[i][1] = max(dp[i - 1][0] + a[i][1], dp[i - 1][2] + a[i][1]);
dp[i][2] = max(dp[i - 1][0] + a[i][2], dp[i - 1][1] + a[i][2]);
}
cout << max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2]));
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const ll mod = 1e9 + 7;
#define rep(i, a, b) for (ll i = a; i < b; i++)
void swap(ll &a, ll &b) {
ll t = a;
a = b;
b = t;
}
ll min(ll a, ll b) {
if (a < b)
return a;
return b;
}
ll max(ll a, ll b) {
if (a > b)
return a;
return b;
}
ll pow(ll a, ll b) {
a %= mod;
ll ans = 1;
while (b > 0) {
if (b & 1)
ans = ans * a % mod;
a = a * a % mod;
b /= 2;
}
return ans;
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
/// 1 2 3 4 ....
ll n;
cin >> n;
ll a[n][3];
for (int i = 0; i < n; i++) {
cin >> a[i][0] >> a[i][1] >> a[i][2];
}
ll dp[n][3];
dp[0][0] = a[0][0];
dp[0][1] = a[0][1];
dp[0][2] = a[0][2];
for (int i = 1; i < n; i++) {
dp[i][0] = max(dp[i - 1][1] + a[i][0], dp[i - 1][2] + a[i][0]);
dp[i][1] = max(dp[i - 1][0] + a[i][1], dp[i - 1][2] + a[i][1]);
dp[i][2] = max(dp[i - 1][0] + a[i][2], dp[i - 1][1] + a[i][2]);
}
cout << max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2]));
}
| [
"identifier.replace.add",
"literal.replace.remove",
"variable_declaration.array_dimensions.change"
] | 963,555 | 963,556 | u537301941 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int a[3][N];
int mem[3][N];
int n;
int vac(int day, int act) {
if (day == n)
return 0;
if (mem[day][act] != -1)
return mem[day][act];
int ans = 0;
ans = max(ans, a[day][act] + vac(day + 1, (act + 1) % 3));
ans = max(ans, a[day][act] + vac(day + 1, (act + 2) % 3));
mem[day][act] = ans;
return mem[day][act];
}
main() {
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d %d %d", &a[i][0], &a[i][1], &a[i][2]);
memset(mem, -1, sizeof mem);
int th1 = vac(0, 0);
int th2 = vac(0, 1);
int th3 = vac(0, 2);
printf("%d\n", max(th1, max(th2, th3)));
return EXIT_SUCCESS;
}
| #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int a[N][3];
int mem[N][3];
int n;
int vac(int day, int act) {
if (day == n)
return 0;
if (mem[day][act] != -1)
return mem[day][act];
int ans = 0;
ans = max(ans, a[day][act] + vac(day + 1, (act + 1) % 3));
ans = max(ans, a[day][act] + vac(day + 1, (act + 2) % 3));
mem[day][act] = ans;
return mem[day][act];
}
main() {
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d %d %d", &a[i][0], &a[i][1], &a[i][2]);
memset(mem, -1, sizeof mem);
int th1 = vac(0, 0);
int th2 = vac(0, 1);
int th3 = vac(0, 2);
printf("%d\n", max(th1, max(th2, th3)));
return EXIT_SUCCESS;
}
| [
"identifier.replace.add",
"literal.replace.remove",
"variable_declaration.array_dimensions.change",
"identifier.replace.remove",
"literal.replace.add"
] | 963,557 | 963,558 | u452706738 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
signed main() {
int n;
cin >> n;
vector<int> dp1(3);
for (int day = 0; day < n; day++) {
vector<int> dp2(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)
dp2[i] = max(dp2[j], dp1[i] + c[j]);
dp1 = dp2;
}
cout << max({dp1[0], dp1[1], dp1[2]}) << "\n";
return false;
} | #include <bits/stdc++.h>
using namespace std;
signed main() {
int n;
cin >> n;
vector<int> dp1(3);
for (int day = 0; day < n; day++) {
vector<int> dp2(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)
dp2[j] = max(dp2[j], dp1[i] + c[j]);
dp1 = dp2;
}
cout << max({dp1[0], dp1[1], dp1[2]}) << "\n";
return false;
} | [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change"
] | 963,563 | 963,564 | u763827124 | cpp |
p03162 | #include "bits/stdc++.h"
using namespace std;
#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__) << "] "
using ll = long long;
const int INF = 1e9 + 5;
int main() {
int n;
scanf("%d", &n);
vector<int> dp(3);
for (int day = 0; day < 3; ++day) {
vector<int> new_dp(3, 0);
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) {
new_dp[j] = max(new_dp[j], dp[i] + c[j]);
}
}
}
dp = new_dp;
}
printf("%d\n", max({dp[0], dp[1], dp[2]}));
return 0;
}
| #include "bits/stdc++.h"
using namespace std;
#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__) << "] "
using ll = long long;
const int INF = 1e9 + 5;
int main() {
int n;
scanf("%d", &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) {
scanf("%d", &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;
}
printf("%d\n", max({dp[0], dp[1], dp[2]}));
return 0;
}
| [
"identifier.replace.add",
"literal.replace.remove"
] | 963,565 | 963,566 | u700811072 | cpp |
p03162 | // author: hitch_hiker42;
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n;
cin >> n;
int a[n], b[n], c[n];
for (int i = 0; i < n; ++i)
cin >> a[i] >> b[i] >> c[i];
int dp[3][n];
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[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[0][i - 1], dp[1][i - 1]) + c[i];
}
cout << max(dp[0][n - 1], max(dp[1][n - 1], dp[2][n - 1]));
} // farewell, until we meet again..
| // author: hitch_hiker42;
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n;
cin >> n;
int a[n], b[n], c[n];
for (int i = 0; i < n; ++i)
cin >> a[i] >> b[i] >> c[i];
int dp[3][n];
memset(dp, 0, sizeof dp);
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] = 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[0][i - 1], dp[1][i - 1]) + c[i];
}
cout << max(dp[0][n - 1], max(dp[1][n - 1], dp[2][n - 1]));
} // farewell, until we meet again..
| [
"literal.number.change",
"assignment.variable.change",
"variable_access.subscript.index.change"
] | 963,572 | 963,573 | u683739220 | cpp |
p03162 | // author: hitch_hiker42;
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n;
cin >> n;
int a[n], b[n], c[n];
for (int i = 0; i < n; ++i)
cin >> a[i] >> b[i] >> c[i];
int dp[3][n];
memset(dp, 0, sizeof dp);
dp[0][0] = a[0];
dp[0][1] = b[0];
dp[1][0] = c[0];
for (int i = 1; i < n; ++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[0][i - 1], dp[1][i - 1]) + c[i];
}
cout << max(dp[0][n - 1], max(dp[1][n - 1], dp[2][n - 1]));
} // farewell, until we meet again.. | // author: hitch_hiker42;
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n;
cin >> n;
int a[n], b[n], c[n];
for (int i = 0; i < n; ++i)
cin >> a[i] >> b[i] >> c[i];
int dp[3][n];
memset(dp, 0, sizeof dp);
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] = 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[0][i - 1], dp[1][i - 1]) + c[i];
}
cout << max(dp[0][n - 1], max(dp[1][n - 1], dp[2][n - 1]));
} // farewell, until we meet again..
| [
"literal.number.change",
"assignment.variable.change",
"variable_access.subscript.index.change"
] | 963,574 | 963,573 | u683739220 | cpp |
p03162 |
#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
#define INF 2147483647
#define lINF 9223372036854775807
#define MODE 1
#ifdef MODE
#define DEB(X) cout << #X << ": " << X << " ";
#define ARDEB(i, X) cout << #X << "[" << i << "]: " << X[i] << " ";
#define END cout << endl;
#else
#define DEB(X) \
{}
#define ARDEB(i, X) \
{}
#define END \
{}
#endif
typedef long long int ll;
ll n, a[111111], b[111111], c[111111], m[111111][3];
ll dp(int i, int ke) {
if (m[i][ke] != -1)
return m[i][ke];
if (i == n)
return 0;
ll sum = 0, sum2 = 0, sum3 = 0;
if (ke != 1)
sum = dp(i + 1, 1) + a[i];
if (ke != 2)
sum2 = dp(i + 1, 2) + b[i];
if (ke != 3)
sum3 = dp(i + 1, 3) + c[i];
return m[i][ke] = max({sum, sum2, sum3});
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i] >> c[i];
for (int j = 0; j < n; j++) {
m[i][j] = -1;
}
}
cout << dp(0, 0) << endl;
return 0;
} |
#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
#define INF 2147483647
#define lINF 9223372036854775807
#define MODE 1
#ifdef MODE
#define DEB(X) cout << #X << ": " << X << " ";
#define ARDEB(i, X) cout << #X << "[" << i << "]: " << X[i] << " ";
#define END cout << endl;
#else
#define DEB(X) \
{}
#define ARDEB(i, X) \
{}
#define END \
{}
#endif
typedef long long int ll;
ll n, a[111111], b[111111], c[111111], m[111111][4];
ll dp(int i, int ke) {
if (m[i][ke] != -1)
return m[i][ke];
if (i == n)
return 0;
ll sum = 0, sum2 = 0, sum3 = 0;
if (ke != 1)
sum = dp(i + 1, 1) + a[i];
if (ke != 2)
sum2 = dp(i + 1, 2) + b[i];
if (ke != 3)
sum3 = dp(i + 1, 3) + c[i];
return m[i][ke] = max({sum, sum2, sum3});
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i] >> c[i];
for (int j = 0; j < 4; j++) {
m[i][j] = -1;
}
}
cout << dp(0, 0) << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 963,584 | 963,585 | u901561754 | cpp |
p03162 | #include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main() {
int N;
cin >> N;
long long a[N][3];
for (int i = 0; i < N; ++i) {
for (int j = 0; j < 3; ++j) {
cin >> a[i][j];
}
}
// DP テーブル
long long dp[N][3];
for (int i = 0; i < N; ++i) {
for (int j = 0; j < 3; ++j) {
dp[i][j] = 0;
}
}
// ループ
for (int i = 0; i < N; ++i) {
for (int j = 0; j < 3; ++j) {
for (int k = 0; k < 3; ++k) {
if (j == k)
continue;
chmax(dp[i + 1][k], dp[i][j] + a[i][k]);
}
}
}
// 解を得て出力
long long res = 0;
for (int i = 0; i < 3; ++i) {
chmax(res, dp[N - 1][i]);
}
cout << res << endl;
return 0;
} | #include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main() {
int N;
cin >> N;
long long a[N][3];
for (int i = 0; i < N; ++i) {
for (int j = 0; j < 3; ++j) {
cin >> a[i][j];
}
}
// DP テーブル
long long dp[N + 1][3];
for (int i = 0; i < N + 1; ++i) {
for (int j = 0; j < 3; ++j) {
dp[i][j] = 0;
}
}
// ループ
for (int i = 0; i < N; ++i) {
for (int j = 0; j < 3; ++j) {
for (int k = 0; k < 3; ++k) {
if (j == k)
continue;
chmax(dp[i + 1][k], dp[i][j] + a[i][k]);
}
}
}
// 解を得て出力
long long res = 0;
for (int i = 0; i < 3; ++i) {
chmax(res, dp[N][i]);
}
cout << res << endl;
return 0;
} | [
"control_flow.loop.for.condition.change",
"misc.off_by_one",
"expression.operation.binary.remove"
] | 963,588 | 963,589 | u933962236 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
long long i, j, n, m, t, k, ans, x, dp[200001][3], B, a[200001][3], Min1, Min2;
int main() {
cin >> n;
cin >> k;
for (i = 1; i <= n; i++) {
cin >> a[i][0] >> a[i][1] >> a[i][2];
}
dp[1][0] = a[1][0];
dp[1][1] = a[1][1];
dp[1][2] = a[1][2];
for (i = 2; i <= n; i++) {
dp[i][0] = a[i][0] + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = a[i][1] + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = a[i][2] + max(dp[i - 1][0], dp[i - 1][1]);
}
cout << max(dp[n][0], max(dp[n][1], dp[n][2])) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
long long i, j, n, m, t, k, ans, x, dp[200001][3], B, a[200001][3], Min1, Min2;
int main() {
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a[i][0] >> a[i][1] >> a[i][2];
}
dp[1][0] = a[1][0];
dp[1][1] = a[1][1];
dp[1][2] = a[1][2];
for (i = 2; i <= n; i++) {
dp[i][0] = a[i][0] + max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] = a[i][1] + max(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = a[i][2] + max(dp[i - 1][0], dp[i - 1][1]);
}
cout << max(dp[n][0], max(dp[n][1], dp[n][2])) << endl;
return 0;
} | [] | 963,590 | 963,591 | u427421765 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define rep_1(i, n) for (int(i) = 0; (i) <= (n); (i)++)
#define rep_2(i, a, b) for (int(i) = (a); (i) < (b); (i)++)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
const int INF = 1e9;
const int MOD = 1e9 + 7;
const ll LINF = 1e18;
int main() {
int n;
cin >> n;
vector<vector<ll>> a(n, vector<ll>(3));
vector<vector<ll>> dp(n + 1, vector<ll>(3));
rep(i, n) {
rep(j, 3) { cin >> a[i][j]; }
}
rep(i, n) {
rep(j, 3) {
rep(k, 3) {
if (j == k)
continue;
dp[i + 1][k] = max(dp[i + 1][k], dp[i][k] + a[i][j]);
}
}
}
ll ans = 0;
rep(i, 3) ans = max(ans, dp[n][i]);
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define rep_1(i, n) for (int(i) = 0; (i) <= (n); (i)++)
#define rep_2(i, a, b) for (int(i) = (a); (i) < (b); (i)++)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
const int INF = 1e9;
const int MOD = 1e9 + 7;
const ll LINF = 1e18;
int main() {
int n;
cin >> n;
vector<vector<ll>> a(n, vector<ll>(3));
vector<vector<ll>> dp(n + 1, vector<ll>(3));
rep(i, n) {
rep(j, 3) { cin >> a[i][j]; }
}
rep(i, n) {
rep(j, 3) {
rep(k, 3) {
if (j == k)
continue;
dp[i + 1][k] = max(dp[i + 1][k], dp[i][j] + a[i][k]);
}
}
}
ll ans = 0;
rep(i, 3) ans = max(ans, dp[n][i]);
cout << ans << endl;
return 0;
}
| [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 963,596 | 963,597 | u709751610 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int maax(int a, int b) {
if (a > b)
return a;
return b;
}
int main() {
int t;
cin >> t;
int a[t], b[t], c[t];
for (int i = 0; i < t; i++) {
cin >> a[t] >> b[t] >> c[t];
}
for (int i = 1; i < t; i++) {
a[i] += maax(b[i - 1], c[i - 1]);
b[i] += maax(c[i - 1], a[i - 1]);
c[i] += maax(a[i - 1], b[i - 1]);
}
cout << maax(maax(a[t - 1], b[t - 1]), c[t - 1]);
} | #include <bits/stdc++.h>
using namespace std;
int maax(int a, int b) {
if (a > b)
return a;
return b;
}
int main() {
int t;
cin >> t;
int a[t], b[t], c[t];
for (int i = 0; i < t; i++) {
cin >> a[i] >> b[i] >> c[i];
}
for (int i = 1; i < t; i++) {
a[i] += maax(b[i - 1], c[i - 1]);
b[i] += maax(c[i - 1], a[i - 1]);
c[i] += maax(a[i - 1], b[i - 1]);
}
cout << maax(maax(a[t - 1], b[t - 1]), c[t - 1]);
} | [
"identifier.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 963,601 | 963,602 | u093796889 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll n, pa, pb, pc, a, b, c;
cin >> n >> pa >> pb >> pc;
for (int i = 1; i < n; i++) {
cin >> a >> b >> c;
a += max(pb, pc);
b += max(pa, pc);
c += max(pa, pb);
pa = a;
pb = b;
pc = c;
}
cout << max(a, max(b, c));
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll n, pa, pb, pc, a, b, c;
cin >> n >> pa >> pb >> pc;
for (int i = 1; i < n; i++) {
cin >> a >> b >> c;
a += max(pb, pc);
b += max(pa, pc);
c += max(pa, pb);
pa = a;
pb = b;
pc = c;
}
// cout << max(a, max(b, c)) << endl;
cout << max(pa, max(pb, pc));
return 0;
}
| [
"identifier.change",
"io.output.change"
] | 963,603 | 963,604 | u242195640 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll n, pa, pb, pc, a, b, c;
cin >> n >> pa >> pb >> pc;
for (int i = 1; i < n; i++) {
cin >> a >> b >> c;
a += max(pb, pc);
b += max(pa, pc);
c += max(pa, pb);
pa = a, pb = b, pc = c;
}
cout << max(a, max(b, c));
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll n, pa, pb, pc, a, b, c;
cin >> n >> pa >> pb >> pc;
for (int i = 1; i < n; i++) {
cin >> a >> b >> c;
a += max(pb, pc);
b += max(pa, pc);
c += max(pa, pb);
pa = a;
pb = b;
pc = c;
}
// cout << max(a, max(b, c)) << endl;
cout << max(pa, max(pb, pc));
return 0;
}
| [
"identifier.change",
"io.output.change"
] | 963,605 | 963,604 | u242195640 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef vector<ll> vi;
typedef pair<ll, ll> pii;
typedef vector<pii> vii;
typedef map<ll, ll> mii;
const int MOD = 1e9 + 7;
#define fastIO() \
ios_base::sync_with_stdio(false); \
cin.tie(nullptr);
#define endl "\n"
#define pb push_back
#define ff first
#define ss second
#define mp make_pair
int main() {
int n;
cin >> n;
vi a(n), b(n), c(n);
for (int i = 0; i < n; ++i) {
cin >> a[i] >> b[i] >> c[i];
}
ll ca = 0, cb = 0, cc = 0;
ll pa = a[0], pb = b[0], pc = c[0];
for (int i = 1; i < n; ++i) {
ca = max(pb, pc) + a[i];
cb = max(pa, pc) + b[i];
cc = max(pa, pb) + c[i];
pa = ca, pb = cb, pc = cc;
}
cout << max(ca, max(cb, cc)) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef vector<ll> vi;
typedef pair<ll, ll> pii;
typedef vector<pii> vii;
typedef map<ll, ll> mii;
const int MOD = 1e9 + 7;
#define fastIO() \
ios_base::sync_with_stdio(false); \
cin.tie(nullptr);
#define endl "\n"
#define pb push_back
#define ff first
#define ss second
#define mp make_pair
int main() {
int n;
cin >> n;
vi a(n), b(n), c(n);
for (int i = 0; i < n; ++i) {
cin >> a[i] >> b[i] >> c[i];
}
ll ca = 0, cb = 0, cc = 0;
ll pa = a[0], pb = b[0], pc = c[0];
for (int i = 1; i < n; ++i) {
ca = max(pb, pc) + a[i];
cb = max(pa, pc) + b[i];
cc = max(pa, pb) + c[i];
pa = ca, pb = cb, pc = cc;
}
cout << max(pa, max(pb, pc)) << endl;
return 0;
}
| [
"identifier.change",
"io.output.change"
] | 963,610 | 963,611 | u697384706 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int koszta[1000006][3]; // koszty kwiatkow
int tab[1000006][3]; // koszt do rabatki dal koloru a kazym numerze na koncu
int n, best;
void dp() {
for (int i = 2; i <= n; i++) { // przejdz po domach
tab[i][0] = max(tab[i - 1][1], tab[i - 1][2]) + koszta[i][0];
tab[i][1] = max(tab[i - 1][0], tab[i - 1][2]) + koszta[i][1];
tab[i][2] = max(tab[i - 1][0], tab[i - 1][1]) + koszta[i][2];
}
}
void prubuj() {
tab[1][1] = koszta[1][1];
tab[1][0] = koszta[1][0];
tab[1][2] = koszta[1][2];
dp();
best = max(min(tab[n][0], tab[n][1]), tab[n][2]);
}
void wczyt() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> koszta[i][0] >> koszta[i][1] >> koszta[i][2];
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
wczyt();
prubuj();
cout << best;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int koszta[1000006][3]; // koszty kwiatkow
int tab[1000006][3]; // koszt do rabatki dal koloru a kazym numerze na koncu
int n, best;
void dp() {
for (int i = 2; i <= n; i++) { // przejdz po domach
tab[i][0] = max(tab[i - 1][1], tab[i - 1][2]) + koszta[i][0];
tab[i][1] = max(tab[i - 1][0], tab[i - 1][2]) + koszta[i][1];
tab[i][2] = max(tab[i - 1][0], tab[i - 1][1]) + koszta[i][2];
}
}
void prubuj() {
tab[1][1] = koszta[1][1];
tab[1][0] = koszta[1][0];
tab[1][2] = koszta[1][2];
dp();
best = max(max(tab[n][0], tab[n][1]), tab[n][2]);
}
void wczyt() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> koszta[i][0] >> koszta[i][1] >> koszta[i][2];
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
wczyt();
prubuj();
cout << best;
return 0;
} | [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change",
"call.arguments.change"
] | 963,612 | 963,613 | u829712891 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, dis1 = 0, dis2 = 0, m, k;
cin >> n;
int arra[n] = {9};
fill(arra, arra + n, 999999999);
vector<int> dp(3, 0);
for (int day = 0; day < n; day++) {
vector<int> vec;
vector<int> new_dp(3, 0);
for (int i = 0; i < 3; i++) {
cin >> m;
vec.push_back(m);
}
// cout<<vec[0]<<endl;
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] + vec[j]));
// cout<<"newdp"<<new_dp[j]<<"dp i= "<<dp[i]<<"vec j= "<<vec[j]<<endl;
}
}
dp = new_dp;
}
// cout<<dp[0]<<endl;
cout << max(dp[0], max(dp[2], dp[3])) << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, dis1 = 0, dis2 = 0, m, k;
cin >> n;
int arra[n] = {9};
fill(arra, arra + n, 999999999);
vector<int> dp(3, 0);
for (int day = 0; day < n; day++) {
vector<int> vec;
vector<int> new_dp(3, 0);
for (int i = 0; i < 3; i++) {
cin >> m;
vec.push_back(m);
}
// cout<<vec[0]<<endl;
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] + vec[j]));
// cout<<"newdp"<<new_dp[j]<<"dp i= "<<dp[i]<<"vec j= "<<vec[j]<<endl;
}
}
dp = new_dp;
}
// cout<<dp[0]<<endl;
cout << max(dp[0], max(dp[1], dp[2])) << endl;
}
| [
"literal.number.change",
"variable_access.subscript.index.change",
"io.output.change"
] | 963,614 | 963,615 | u998339520 | cpp |
p03162 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n], b[n], c[n], fc[n], fb[n], fa[n];
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i] >> c[i];
}
fc[0] = c[0];
fb[0] = b[0];
fa[0] = a[0];
for (int i = 1; i < n; i++) {
fc[i] = c[i] + max(fb[i - 1], fa[i - 1]);
fb[i] = b[i] + max(fa[i - 1], fc[i - 1]);
fa[i] = a[i] + max(fb[i - 1], fc[i - 1]);
}
cout << max(max(fc[n - 1], fb[n - 1]), fc[n - 1]) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n], b[n], c[n], fc[n], fb[n], fa[n];
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i] >> c[i];
}
fc[0] = c[0];
fb[0] = b[0];
fa[0] = a[0];
for (int i = 1; i < n; i++) {
fc[i] = c[i] + max(fb[i - 1], fa[i - 1]);
fb[i] = b[i] + max(fa[i - 1], fc[i - 1]);
fa[i] = a[i] + max(fb[i - 1], fc[i - 1]);
}
cout << max(max(fc[n - 1], fb[n - 1]), fa[n - 1]) << endl;
return 0;
}
| [
"identifier.change",
"io.output.change"
] | 963,618 | 963,619 | u746339181 | cpp |
p03162 | #include <stdio.h>
int main() {
int i;
scanf("%d", &i);
int k = -1;
int tab[i][3];
while (++k < i)
scanf("%d %d %d", &tab[k][0], &tab[k][1], &tab[k][2]);
k = 0;
while (++k < i) {
tab[k][0] = tab[k][0] + ((tab[k - 1][1] >= tab[k - 1][2]) ? tab[k - 1][1]
: tab[k - 1][2]);
tab[k][1] = tab[k][1] + ((tab[k - 1][0] >= tab[k - 1][2]) ? tab[k - 1][0]
: tab[k - 1][2]);
tab[k][2] = tab[k][2] + ((tab[k - 1][1] >= tab[k - 1][0]) ? tab[k - 1][1]
: tab[k - 1][0]);
}
if (tab[i - 1][0] > tab[1 - 1][1]) {
if (tab[i - 1][0] > tab[1 - 1][2])
printf("%d", tab[i - 1][0]);
else
printf("%d", tab[i - 1][2]);
} else {
if (tab[i - 1][1] > tab[1 - 1][2])
printf("%d", tab[i - 1][1]);
else
printf("%d", tab[i - 1][2]);
}
} | #include <stdio.h>
int main() {
int i;
scanf("%d", &i);
int k = -1;
int tab[i][3];
while (++k < i)
scanf("%d %d %d", &tab[k][0], &tab[k][1], &tab[k][2]);
k = 0;
while (++k < i) {
tab[k][0] = tab[k][0] + ((tab[k - 1][1] >= tab[k - 1][2]) ? tab[k - 1][1]
: tab[k - 1][2]);
tab[k][1] = tab[k][1] + ((tab[k - 1][0] >= tab[k - 1][2]) ? tab[k - 1][0]
: tab[k - 1][2]);
tab[k][2] = tab[k][2] + ((tab[k - 1][1] >= tab[k - 1][0]) ? tab[k - 1][1]
: tab[k - 1][0]);
}
if (tab[i - 1][0] > tab[i - 1][1]) {
if (tab[i - 1][0] > tab[i - 1][2])
printf("%d", tab[i - 1][0]);
else
printf("%d", tab[i - 1][2]);
} else {
if (tab[i - 1][1] > tab[i - 1][2])
printf("%d", tab[i - 1][1]);
else
printf("%d", tab[i - 1][2]);
}
} | [
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 963,622 | 963,623 | u896013930 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.