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 |
|---|---|---|---|---|---|---|---|
p03160 | #include <iostream>
#include <math.h>
using namespace std;
int main() {
int N;
cin >> N;
int cost[N], height[N];
for (int i = 0; i < N; i++) {
cin >> height[i];
if (i == 0)
cost[i] = 0;
else
cost[i] = 2147483627;
}
for (int i = 0; i < N; i++) {
if (i + 1 < N)
cost[i + 1] = min(cost[i + 1], cost[i] + abs(cost[i] - cost[i + 1]));
if (i + 2 < N)
cost[i + 2] = min(cost[i + 2], cost[i + 1] + abs(cost[i] - cost[i + 2]));
}
cout << cost[N - 1] << endl;
return 0;
} | #include <iostream>
#include <math.h>
using namespace std;
int main() {
int N;
cin >> N;
int cost[N], height[N];
for (int i = 0; i < N; i++) {
cin >> height[i];
if (i == 0)
cost[i] = 0;
else
cost[i] = 2147483627;
}
for (int i = 0; i < N; i++) {
if (i + 1 < N)
cost[i + 1] = min(cost[i + 1], cost[i] + abs(height[i] - height[i + 1]));
if (i + 2 < N)
cost[i + 2] = min(cost[i + 2], cost[i] + abs(height[i] - height[i + 2]));
}
cout << cost[N - 1] << endl;
return 0;
} | [
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 953,303 | 953,302 | u002439051 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int dp[n];
dp[n - 1] = 0;
dp[n - 2] = abs(a[n - 1] - a[n - 1]);
for (int i = n - 3; i >= 0; i--) {
dp[i] =
min(abs(a[i] - a[i + 1]) + dp[i + 1], abs(a[i] - a[i + 2]) + dp[i + 2]);
}
cout << dp[0] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int dp[n];
dp[n - 1] = 0;
dp[n - 2] = abs(a[n - 1] - a[n - 2]);
for (int i = n - 3; i >= 0; i--) {
dp[i] =
min(abs(a[i] - a[i + 1]) + dp[i + 1], abs(a[i] - a[i + 2]) + dp[i + 2]);
}
cout << dp[0] << endl;
return 0;
} | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 953,308 | 953,309 | u837533136 | cpp |
p03160 | #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];
void solve() {
lli n;
cin >> n;
lli a[n];
for (int i = 1; i <= n; i++)
cin >> a[i];
for (int i = 1; i < n + 500; i++)
dp[i] = 1e5;
dp[1] = 0;
for (int i = 1; i <= n; i++) {
dp[i + 1] = min(dp[i + 1], dp[i] + abs(a[i] - a[i + 1]));
dp[i + 2] = min(dp[i + 2], dp[i] + abs(a[i] - a[i + 2]));
}
cout << dp[n] << 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];
void solve() {
lli n;
cin >> n;
lli a[n];
for (int i = 1; i <= n; i++)
cin >> a[i];
for (int i = 1; i < n + 500; i++)
dp[i] = 1e9;
dp[1] = 0;
for (int i = 1; i <= n; i++) {
dp[i + 1] = min(dp[i + 1], dp[i] + abs(a[i] - a[i + 1]));
dp[i + 2] = min(dp[i + 2], dp[i] + abs(a[i] - a[i + 2]));
}
cout << dp[n] << 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;
}
| [
"literal.number.change",
"assignment.value.change"
] | 953,315 | 953,316 | u684423349 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int dp[100] = {0};
int main() {
int n, i;
cin >> n;
int arr[n];
for (i = 0; i < n; i++) {
cin >> arr[i];
}
dp[0] = 0;
dp[1] = abs(arr[1] - arr[0]);
for (i = 2; i < n; i++) {
dp[i] = min(dp[i - 1] + abs(arr[i] - arr[i - 1]),
dp[i - 2] + abs(arr[i] - arr[i - 2]));
}
cout << dp[n - 1] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
long int dp[100001] = {0};
int main() {
long int n, i;
cin >> n;
long int arr[n];
for (i = 0; i < n; i++) {
cin >> arr[i];
}
dp[0] = 0;
dp[1] = abs(arr[1] - arr[0]);
for (i = 2; i < n; i++) {
dp[i] = min(dp[i - 1] + abs(arr[i] - arr[i - 1]),
dp[i - 2] + abs(arr[i] - arr[i - 2]));
}
cout << dp[n - 1] << endl;
return 0;
} | [
"variable_declaration.type.widen.change",
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 953,320 | 953,321 | u537339800 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define pb push_back
#define mp make_pair
#define endl "\n"
ll h[100005];
ll mini[100005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll N;
cin >> N;
for (ll i = 0; i < N; i++) {
cin >> h[i];
}
mini[0] = h[0];
mini[1] = abs(h[1] - h[0]);
mini[2] = min(mini[1] + abs(h[2] - h[1]), h[2] - h[0]);
for (ll j = 3; j < N; j++) {
mini[j] = min(mini[j - 1] + abs(h[j] - h[j - 1]),
mini[j - 2] + abs(h[j] - h[j - 2]));
}
cout << mini[N - 1] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define pb push_back
#define mp make_pair
#define endl "\n"
ll h[100005];
ll mini[100005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll N;
cin >> N;
for (ll i = 0; i < N; i++) {
cin >> h[i];
}
mini[0] = h[0];
mini[1] = abs(h[1] - h[0]);
mini[2] = min(mini[1] + abs(h[2] - h[1]), abs(h[2] - h[0]));
for (ll j = 3; j < N; j++) {
mini[j] = min(mini[j - 1] + abs(h[j] - h[j - 1]),
mini[j - 2] + abs(h[j] - h[j - 2]));
}
cout << mini[N - 1] << endl;
return 0;
} | [
"call.add",
"call.arguments.change"
] | 953,329 | 953,330 | u616547520 | cpp |
p03160 | #include <bits/stdc++.h>
typedef long long ll;
typedef long double ld;
typedef std::vector<int> vi;
typedef std::vector<long long> vll;
#define pub push_back
#define pob pop_back
#define mp make_pair
#define ff first
#define ss second
#define umap unordered_map
#define uset unordered_set
#define forn(i, n) for (ll i = 0; i < (ll)n; i++)
#define forf(i, x, y) for (ll i = (x); i <= (ll)y; i++)
#define forb(i, x, y) for (ll i = (x); i >= (ll)y; i--)
#define lpt() \
ll T; \
std::cin >> T; \
while (T--)
#define nl "\n"
#define newl std::cout << "\n";
#define bug(x) std::cerr << "debug " << #x << " : " << x << "\n";
#define all(x) x.begin(), x.end()
#define fastio() \
ios::sync_with_stdio(false); \
std::cin.tie(0); \
std::cout.tie(0);
template <typename X>
std::ostream &operator<<(std::ostream &out, std::vector<X> v) {
for (auto &i : v)
out << i << " ";
return out;
}
template <typename X, typename Y>
std::ostream &operator<<(std::ostream &out, std::pair<X, Y> p) {
out << p.first << " " << p.second;
return out;
}
static const long long mod = 1000000007;
using namespace std;
ll mem[100000];
vi v;
ll cost(ll i) {
if (mem[i] != -1)
return mem[i];
return mem[i] = min(abs(v[i + 1] - v[i]) + cost(i + 1),
abs(v[i + 2] - v[i]) + cost(i + 2));
}
int main() {
fastio();
int n;
cin >> n;
forn(i, n) {
ll temp;
cin >> temp;
v.pub(temp);
}
memset(mem, -1, sizeof mem);
mem[n - 2] = v[n - 2] - v[n - 1];
mem[n - 1] = 0;
cout << cost(0) << nl;
return 0;
}
| #include <bits/stdc++.h>
typedef long long ll;
typedef long double ld;
typedef std::vector<int> vi;
typedef std::vector<long long> vll;
#define pub push_back
#define pob pop_back
#define mp make_pair
#define ff first
#define ss second
#define umap unordered_map
#define uset unordered_set
#define forn(i, n) for (ll i = 0; i < (ll)n; i++)
#define forf(i, x, y) for (ll i = (x); i <= (ll)y; i++)
#define forb(i, x, y) for (ll i = (x); i >= (ll)y; i--)
#define lpt() \
ll T; \
std::cin >> T; \
while (T--)
#define nl "\n"
#define newl std::cout << "\n";
#define bug(x) std::cerr << "debug " << #x << " : " << x << "\n";
#define all(x) x.begin(), x.end()
#define fastio() \
ios::sync_with_stdio(false); \
std::cin.tie(0); \
std::cout.tie(0);
template <typename X>
std::ostream &operator<<(std::ostream &out, std::vector<X> v) {
for (auto &i : v)
out << i << " ";
return out;
}
template <typename X, typename Y>
std::ostream &operator<<(std::ostream &out, std::pair<X, Y> p) {
out << p.first << " " << p.second;
return out;
}
static const long long mod = 1000000007;
using namespace std;
ll mem[100000];
vi v;
ll cost(ll i) {
if (mem[i] != -1)
return mem[i];
return mem[i] = min(abs(v[i + 1] - v[i]) + cost(i + 1),
abs(v[i + 2] - v[i]) + cost(i + 2));
}
int main() {
fastio();
int n;
cin >> n;
forn(i, n) {
ll temp;
cin >> temp;
v.pub(temp);
}
memset(mem, -1, sizeof mem);
mem[n - 2] = abs(v[n - 2] - v[n - 1]);
mem[n - 1] = 0;
cout << cost(0) << nl;
return 0;
}
| [
"call.add",
"call.arguments.change"
] | 953,333 | 953,334 | u532327992 | cpp |
p03160 | #include <bits/stdc++.h>
#define ll long long int
#define ld long double
#define loop(i, a, b) for (i = a; i < b; i++)
#define pb push_back
#define mp make_pair
#define mod 1000000007
using namespace std;
int main() {
ll n, i, j;
cin >> n;
ll a[n], dp[n + 3];
loop(i, 0, n) cin >> a[i];
dp[0] = 0;
dp[1] = abs(a[0] - a[1]);
dp[2] = abs(a[2] - a[1]);
loop(i, 3, n) dp[i] =
min(dp[i - 1] + abs(a[i] - a[i - 1]), dp[i - 2] + abs(a[i] - a[i - 2]));
cout << dp[n - 1] << endl;
return 0;
} | #include <bits/stdc++.h>
#define ll long long int
#define ld long double
#define loop(i, a, b) for (i = a; i < b; i++)
#define pb push_back
#define mp make_pair
#define mod 1000000007
using namespace std;
int main() {
ll n, i, j;
cin >> n;
ll a[n], dp[n + 3];
loop(i, 0, n) cin >> a[i];
dp[0] = 0;
dp[1] = abs(a[0] - a[1]);
dp[2] = abs(a[2] - a[0]);
loop(i, 3, n) dp[i] =
min(dp[i - 1] + abs(a[i] - a[i - 1]), dp[i - 2] + abs(a[i] - a[i - 2]));
cout << dp[n - 1] << endl;
return 0;
} | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 953,335 | 953,336 | u379656178 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ar[n];
for (int i = 0; i < n; ++i)
cin >> ar[i];
int dp[n + 1];
dp[0] = 0;
dp[1] = abs(ar[1] - ar[0]);
for (int i = 2; i < n; ++i) {
dp[i] =
min(dp[i] + abs(ar[i - 1] - ar[i]), dp[i - 1] + abs(ar[i - 2] - ar[i]));
}
cout << dp[n] << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ar[n];
for (int i = 0; i < n; ++i)
cin >> ar[i];
int dp[n + 1];
dp[0] = 0;
dp[1] = abs(ar[1] - ar[0]);
for (int i = 2; i < n; ++i) {
dp[i] = min(dp[i - 1] + abs(ar[i - 1] - ar[i]),
dp[i - 2] + abs(ar[i - 2] - ar[i]));
}
cout << dp[n - 1] << endl;
} | [
"assignment.change",
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 953,337 | 953,338 | u135066978 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ar[n];
for (int i = 0; i < n; ++i)
cin >> ar[i];
int dp[n + 1];
dp[0] = 0;
dp[1] = abs(ar[1] - ar[0]);
for (int i = 2; i < n; ++i) {
dp[i] = min(dp[i - 1] + abs(ar[i - 1] - ar[i]),
dp[i - 2] + abs(ar[i - 2] - ar[i]));
}
cout << dp[n] << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ar[n];
for (int i = 0; i < n; ++i)
cin >> ar[i];
int dp[n + 1];
dp[0] = 0;
dp[1] = abs(ar[1] - ar[0]);
for (int i = 2; i < n; ++i) {
dp[i] = min(dp[i - 1] + abs(ar[i - 1] - ar[i]),
dp[i - 2] + abs(ar[i - 2] - ar[i]));
}
cout << dp[n - 1] << endl;
} | [
"expression.operation.binary.add"
] | 953,339 | 953,338 | u135066978 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++)
cin >> arr[i];
int dp[n];
memset(dp, 0, sizeof(dp));
dp[0] = arr[0];
dp[1] = abs(arr[1] - arr[0]);
for (int i = 2; i < n; i++) {
int f = dp[i - 1] + abs(arr[i] - arr[i - 1]);
int s = dp[i - 2] + abs(arr[i] - arr[i - 2]);
dp[i] = min(f, s);
}
cout << dp[n - 1] << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++)
cin >> arr[i];
int dp[n];
memset(dp, 0, sizeof(dp));
dp[0] = 0;
dp[1] = abs(arr[1] - arr[0]);
for (int i = 2; i < n; i++) {
int f = dp[i - 1] + abs(arr[i] - arr[i - 1]);
int s = dp[i - 2] + abs(arr[i] - arr[i - 2]);
dp[i] = min(f, s);
}
cout << dp[n - 1] << endl;
} | [] | 953,340 | 953,341 | u965448987 | cpp |
p03159 | #include <bits/stdc++.h>
using namespace std;
long long dp[5010][5010];
long long tmp[5010];
bool pos[5010][5010];
bool ptmp[5010];
int sz[5010];
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<long long> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
vector<vector<int>> e(n);
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
u--, v--;
e[u].emplace_back(v);
e[v].emplace_back(u);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j <= n; j++) {
dp[i][j] = 1e16;
}
}
auto f = [&](auto f, int curr, int prev) -> void {
sz[curr] = 1;
pos[curr][0] = (a[curr] > 0);
dp[curr][0] = a[curr];
for (auto &to : e[curr]) {
if (to == prev)
continue;
f(f, to, curr);
for (int i = 0; i < n; i++)
tmp[i] = 1e16, ptmp[i] = 0;
for (int i = 0; i < sz[curr]; i--) {
for (int j = 0; j < sz[to]; j++) {
if (pos[to][j] || dp[to][j] < 0) {
tmp[i + j + 1] = min(tmp[i + j + 1], dp[curr][i]);
ptmp[i + j + 1] |= pos[curr][i];
}
ptmp[i + j] |= pos[curr][i] & pos[to][j];
tmp[i + j] = min(tmp[i + j], dp[curr][i] + dp[to][j]);
}
}
sz[curr] += sz[to];
for (int i = 0; i < sz[curr]; i++) {
dp[curr][i] = tmp[i];
pos[curr][i] = ptmp[i];
}
}
};
f(f, 0, -1);
for (int i = 0; i < n; i++) {
if (dp[0][i] < 0 || pos[0][i]) {
cout << i << "\n";
return 0;
}
}
assert(false);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
long long dp[5010][5010];
long long tmp[5010];
bool pos[5010][5010];
bool ptmp[5010];
int sz[5010];
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<long long> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
vector<vector<int>> e(n);
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
u--, v--;
e[u].emplace_back(v);
e[v].emplace_back(u);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j <= n; j++) {
dp[i][j] = 1e16;
}
}
auto f = [&](auto f, int curr, int prev) -> void {
sz[curr] = 1;
pos[curr][0] = (a[curr] > 0);
dp[curr][0] = a[curr];
for (auto &to : e[curr]) {
if (to == prev)
continue;
f(f, to, curr);
for (int i = 0; i < n; i++)
tmp[i] = 1e16, ptmp[i] = 0;
for (int i = 0; i < sz[curr]; i++) {
for (int j = 0; j < sz[to]; j++) {
if (pos[to][j] || dp[to][j] < 0) {
tmp[i + j + 1] = min(tmp[i + j + 1], dp[curr][i]);
ptmp[i + j + 1] |= pos[curr][i];
}
ptmp[i + j] |= pos[curr][i] & pos[to][j];
tmp[i + j] = min(tmp[i + j], dp[curr][i] + dp[to][j]);
}
}
sz[curr] += sz[to];
for (int i = 0; i < sz[curr]; i++) {
dp[curr][i] = tmp[i];
pos[curr][i] = ptmp[i];
}
}
};
f(f, 0, -1);
for (int i = 0; i < n; i++) {
if (dp[0][i] < 0 || pos[0][i]) {
cout << i << "\n";
return 0;
}
}
assert(false);
return 0;
} | [] | 953,360 | 953,361 | u521364030 | cpp |
p03159 | #define _USE_MATH_DEFINES
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define rep(i, a, b) for (int i = (a), i##_len = (b); i < i##_len; i++)
#define rrep(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define all(c) begin(c), end(c)
#define int ll
#define SZ(x) ((int)(x).size())
#define pb push_back
#define mp make_pair
typedef long long ll;
// typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ll, int> pli;
typedef pair<double, double> pdd;
typedef vector<vector<int>> mat;
// typedef unsigned int uint;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
const int INF =
sizeof(int) == sizeof(long long) ? 0x3f3f3f3f3f3f3f3fLL : 0x3f3f3f3f;
const int MOD = (int)1e9 + 7;
const double EPS = 1e-9;
int N;
int A[5010];
int V[5010];
vector<int> G[5010];
int dp[5010][5010][2], temp[5010][2];
void dfs(int v, int p) {
for (auto n : G[v])
if (p != n)
dfs(n, v);
int vs = 1;
dp[v][0][A[v] < 0 ? 1 : 0] = A[v];
for (auto n : G[v])
if (p != n) {
rep(j0, 0, vs) rep(j1, 0, V[n]) rep(k0, 0, 2) rep(k1, 0, 2) {
chmin(temp[j0 + j1][k0 | k1], dp[v][j0][k0] + dp[n][j1][k1]);
if ((k1 == 0 && dp[n][j1][k1] < INF) || dp[n][j1][k1] < 0) {
chmin(temp[j0 + j1 + 1][k0], dp[n][j0][k0]);
}
}
vs += V[n];
rep(j, 0, vs) rep(k, 0, 2) {
dp[v][j][k] = temp[j][k];
temp[j][k] = INF;
}
}
V[v] = vs;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> N;
rep(i, 0, N) cin >> A[i];
int u, v;
rep(i, 0, N - 1) {
cin >> u >> v;
u--, v--;
G[u].push_back(v);
G[v].push_back(u);
}
rep(j, 0, N) rep(k, 0, 2) {
rep(i, 0, 5010) dp[i][j][k] = INF;
temp[j][k] = INF;
}
dfs(0, -1);
int ans = N - 1;
rep(j, 0, N) {
if (dp[0][j][0] < INF)
chmin(ans, j);
if (dp[0][j][1] < 0)
chmin(ans, j);
}
cout << ans << endl;
return 0;
} | #define _USE_MATH_DEFINES
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define rep(i, a, b) for (int i = (a), i##_len = (b); i < i##_len; i++)
#define rrep(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define all(c) begin(c), end(c)
#define int ll
#define SZ(x) ((int)(x).size())
#define pb push_back
#define mp make_pair
typedef long long ll;
// typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ll, int> pli;
typedef pair<double, double> pdd;
typedef vector<vector<int>> mat;
// typedef unsigned int uint;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
const int INF =
sizeof(int) == sizeof(long long) ? 0x3f3f3f3f3f3f3f3fLL : 0x3f3f3f3f;
const int MOD = (int)1e9 + 7;
const double EPS = 1e-9;
int N;
int A[5010];
int V[5010];
vector<int> G[5010];
int dp[5010][5010][2], temp[5010][2];
void dfs(int v, int p) {
for (auto n : G[v])
if (p != n)
dfs(n, v);
int vs = 1;
dp[v][0][A[v] < 0 ? 1 : 0] = A[v];
for (auto n : G[v])
if (p != n) {
rep(j0, 0, vs) rep(j1, 0, V[n]) rep(k0, 0, 2) rep(k1, 0, 2) {
chmin(temp[j0 + j1][k0 | k1], dp[v][j0][k0] + dp[n][j1][k1]);
if ((k1 == 0 && dp[n][j1][k1] < INF) || dp[n][j1][k1] < 0) {
chmin(temp[j0 + j1 + 1][k0], dp[v][j0][k0]);
}
}
vs += V[n];
rep(j, 0, vs) rep(k, 0, 2) {
dp[v][j][k] = temp[j][k];
temp[j][k] = INF;
}
}
V[v] = vs;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> N;
rep(i, 0, N) cin >> A[i];
int u, v;
rep(i, 0, N - 1) {
cin >> u >> v;
u--, v--;
G[u].push_back(v);
G[v].push_back(u);
}
rep(j, 0, N) rep(k, 0, 2) {
rep(i, 0, 5010) dp[i][j][k] = INF;
temp[j][k] = INF;
}
dfs(0, -1);
int ans = N - 1;
rep(j, 0, N) {
if (dp[0][j][0] < INF)
chmin(ans, j);
if (dp[0][j][1] < 0)
chmin(ans, j);
}
cout << ans << endl;
return 0;
} | [
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change"
] | 953,372 | 953,373 | u874947858 | cpp |
p03159 | #include <bits/stdc++.h>
using namespace std;
#define _for(i, j, N) for (int i = (j); i < (N); i++)
#define _rep(i, j, N) for (int i = (j); i <= (N); i++)
#define ALL(x) x.begin(), x.end()
#define pb push_back
#define LL long long
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;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
_for(i, 0, (int)(v.size() - 1)) os << v[i] << " ";
os << v[v.size() - 1];
return os;
}
template <typename T> ostream &operator<<(ostream &os, const set<T> &v) {
for (typename set<T>::iterator it = v.begin(); it != v.end(); it++)
os << *it << " ";
return os;
}
const int maxn = 5005;
int N;
LL A[maxn];
vector<int> G[maxn];
LL res = 0;
struct Cmp {
bool operator()(const int &a, const int &b) const { return A[a] > A[b]; }
};
const LL INF = 1e16;
LL dp[maxn][maxn][2];
LL aux[maxn][2];
int child[maxn];
void dfs(int u, int p) {
for (int j : G[u]) {
if (j == p)
continue;
dfs(j, u);
}
if (A[u] > 0) {
dp[u][0][0] = A[u];
} else
dp[u][0][1] = A[u];
_for(i, 0, maxn) _for(j, 0, 2) aux[i][j] = INF;
int sum = 1;
child[u] = 1;
for (int v : G[u]) {
if (v == p)
continue;
_for(i, 0, sum) {
_for(j, 0, child[v]) {
_for(k1, 0, 2) _for(k2, 0, 2) {
// if(v == 5) cout <<"j:"<<j << "val:"<<dp[5][j][0] <<endl;
if (dp[v][j][k2] < 0 || (!k2 && dp[v][j][k2] < INF)) {
chmin(aux[j + i + 1][k1], dp[u][i][k1]);
}
chmin(aux[i + j][k1 | k2], dp[u][i][k1] + dp[v][j][k2]);
}
}
}
child[u] += child[v];
sum += child[v];
_for(i, 0, maxn) _for(j, 0, 2) {
dp[u][i][j] = aux[i][j];
aux[i][j] = INF;
}
}
}
int main() {
cin >> N;
_rep(i, 1, N) { cin >> A[i]; }
_for(i, 0, N - 1) {
int u, v;
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
_for(i, 0, maxn) _for(j, 0, maxn) _for(k, 0, 2) dp[i][j][k] = INF;
_for(i, 0, maxn) _for(k, 0, 2) aux[i][k] = INF;
dfs(1, -1);
int ans = maxn;
_for(i, 1, maxn) {
if (dp[1][i][1] < 0)
chmin(ans, i);
// cout << dp[1][i][1] << endl;
}
_for(i, 1, maxn) {
if (dp[1][i][0] < INF)
chmin(ans, i);
// cout << child[i] <<endl;
}
// cout << dp[4][2][1] << endl;
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define _for(i, j, N) for (int i = (j); i < (N); i++)
#define _rep(i, j, N) for (int i = (j); i <= (N); i++)
#define ALL(x) x.begin(), x.end()
#define pb push_back
#define LL long long
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;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
_for(i, 0, (int)(v.size() - 1)) os << v[i] << " ";
os << v[v.size() - 1];
return os;
}
template <typename T> ostream &operator<<(ostream &os, const set<T> &v) {
for (typename set<T>::iterator it = v.begin(); it != v.end(); it++)
os << *it << " ";
return os;
}
const int maxn = 5005;
int N;
LL A[maxn];
vector<int> G[maxn];
LL res = 0;
struct Cmp {
bool operator()(const int &a, const int &b) const { return A[a] > A[b]; }
};
const LL INF = 1e16;
LL dp[maxn][maxn][2];
LL aux[maxn][2];
int child[maxn];
void dfs(int u, int p) {
for (int j : G[u]) {
if (j == p)
continue;
dfs(j, u);
}
if (A[u] > 0) {
dp[u][0][0] = A[u];
} else
dp[u][0][1] = A[u];
_for(i, 0, maxn) _for(j, 0, 2) aux[i][j] = INF;
int sum = 1;
child[u] = 1;
for (int v : G[u]) {
if (v == p)
continue;
_for(i, 0, sum) {
_for(j, 0, child[v]) {
_for(k1, 0, 2) _for(k2, 0, 2) {
// if(v == 5) cout <<"j:"<<j << "val:"<<dp[5][j][0] <<endl;
if (dp[v][j][k2] < 0 || (!k2 && dp[v][j][k2] < INF)) {
chmin(aux[j + i + 1][k1], dp[u][i][k1]);
}
chmin(aux[i + j][k1 | k2], dp[u][i][k1] + dp[v][j][k2]);
}
}
}
child[u] += child[v];
sum += child[v];
_for(i, 0, maxn) _for(j, 0, 2) {
dp[u][i][j] = aux[i][j];
aux[i][j] = INF;
}
}
}
int main() {
cin >> N;
_rep(i, 1, N) { cin >> A[i]; }
_for(i, 0, N - 1) {
int u, v;
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
_for(i, 0, maxn) _for(j, 0, maxn) _for(k, 0, 2) dp[i][j][k] = INF;
_for(i, 0, maxn) _for(k, 0, 2) aux[i][k] = INF;
dfs(1, -1);
int ans = maxn;
_for(i, 0, maxn) {
if (dp[1][i][1] < 0)
chmin(ans, i);
// cout << dp[1][i][1] << endl;
}
_for(i, 0, maxn) {
if (dp[1][i][0] < INF)
chmin(ans, i);
// cout << child[i] <<endl;
}
// cout << dp[4][2][1] << endl;
cout << ans << endl;
return 0;
}
| [
"literal.number.change",
"call.arguments.change"
] | 953,380 | 953,381 | u066651036 | cpp |
p03159 | #include <bits/stdc++.h>
#include <ostream>
using namespace std;
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
template <class T> using V = vector<T>;
template <class T> using VV = V<V<T>>;
constexpr ll TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n - 1); }
const ll INF = TEN(18);
int n;
V<ll> a;
VV<int> g;
using P = pair<ll, ll>;
V<P> dfs(int p, int b) {
V<P> dp = {{0, INF}};
for (int d : g[p]) {
if (d == b)
continue;
auto ndp = dfs(d, p);
int k = int(ndp.size());
ndp.push_back({INF, INF});
for (int i = k - 1; i >= 0; i--) {
if (ndp[i].first < INF / 2 || ndp[i].second < 0)
ndp[i + 1].first = min(ndp[i + 1].first, 0LL);
}
int m = int(dp.size()) - 1;
V<P> udp(m + k + 1, {INF, INF});
for (int i = 0; i <= m; i++) {
for (int j = 0; j <= k; j++) {
udp[i + j].first = min(udp[i + j].first, dp[i].first + ndp[j].first);
udp[i + j].second = min(udp[i + j].second, dp[i].first + ndp[j].second);
udp[i + j].second =
min(udp[i + j].second, dp[i].second + ndp[j].second);
udp[i + j].second =
min(udp[i + j].second, dp[i].second + ndp[j].second);
}
}
dp = udp;
}
int m = int(dp.size()) - 1;
V<P> udp(m + 1);
for (int i = 0; i <= m; i++) {
if (a[p] > 0) {
udp[i].first = dp[i].first + a[p];
udp[i].second = dp[i].second + a[p];
} else {
udp[i].first = INF;
udp[i].second = min(dp[i].first, dp[i].second) + a[p];
}
}
return udp;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout << setprecision(20) << fixed;
cin >> n;
a = V<ll>(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
g = VV<int>(n);
for (int j = 0; j < n - 1; ++j) {
int a, b;
cin >> a >> b;
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
}
auto dp = dfs(0, -1);
for (int i = 0; i < n; i++) {
if (dp[i].first < INF / 2 || dp[i].second < 0) {
cout << i << endl;
return 0;
}
}
assert(false);
return 0;
}
| #include <bits/stdc++.h>
#include <ostream>
using namespace std;
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
template <class T> using V = vector<T>;
template <class T> using VV = V<V<T>>;
constexpr ll TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n - 1); }
const ll INF = TEN(18);
int n;
V<ll> a;
VV<int> g;
using P = pair<ll, ll>;
V<P> dfs(int p, int b) {
V<P> dp = {{0, INF}};
for (int d : g[p]) {
if (d == b)
continue;
auto ndp = dfs(d, p);
int k = int(ndp.size());
ndp.push_back({INF, INF});
for (int i = k - 1; i >= 0; i--) {
if (ndp[i].first < INF / 2 || ndp[i].second < 0)
ndp[i + 1].first = min(ndp[i + 1].first, 0LL);
}
int m = int(dp.size()) - 1;
V<P> udp(m + k + 1, {INF, INF});
for (int i = 0; i <= m; i++) {
for (int j = 0; j <= k; j++) {
udp[i + j].first = min(udp[i + j].first, dp[i].first + ndp[j].first);
udp[i + j].second = min(udp[i + j].second, dp[i].first + ndp[j].second);
udp[i + j].second = min(udp[i + j].second, dp[i].second + ndp[j].first);
udp[i + j].second =
min(udp[i + j].second, dp[i].second + ndp[j].second);
}
}
dp = udp;
}
int m = int(dp.size()) - 1;
V<P> udp(m + 1);
for (int i = 0; i <= m; i++) {
if (a[p] > 0) {
udp[i].first = dp[i].first + a[p];
udp[i].second = dp[i].second + a[p];
} else {
udp[i].first = INF;
udp[i].second = min(dp[i].first, dp[i].second) + a[p];
}
}
return udp;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout << setprecision(20) << fixed;
cin >> n;
a = V<ll>(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
g = VV<int>(n);
for (int j = 0; j < n - 1; ++j) {
int a, b;
cin >> a >> b;
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
}
auto dp = dfs(0, -1);
for (int i = 0; i < n; i++) {
if (dp[i].first < INF / 2 || dp[i].second < 0) {
cout << i << endl;
return 0;
}
}
assert(false);
return 0;
}
| [
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 953,398 | 953,399 | u965174248 | cpp |
p03159 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define all(c) c.begin(), c.end()
#define pb push_back
#define fs first
#define sc second
#define show(x) cout << #x << " = " << (x) << endl
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
using namespace std;
template <class S, class T>
ostream &operator<<(ostream &o, const pair<S, T> &p) {
return o << "(" << p.fs << "," << p.sc << ")";
}
template <class T> ostream &operator<<(ostream &o, const vector<T> &vc) {
o << "{";
for (const T &v : vc)
o << v << ",";
o << "}";
return o;
}
using ll = long long;
template <class T> using V = vector<T>;
template <class T> using VV = vector<vector<T>>;
int N;
V<ll> A;
VV<int> G;
V<int> sz;
ll dp[5010][2][5010];
ll inner[2][5010];
ll ninner[2][5010];
ll inf = 1e18;
void dfs(int v, int p) {
sz[v] = 1;
for (int u : G[v])
if (u != p)
dfs(u, v), sz[v] += sz[u];
int S = 1;
inner[0][0] = inner[1][0] = A[v];
if (A[v] < 0)
inner[1][0] = inf;
for (int u : G[v])
if (u != p) {
rep(i, 2) rep(j, S + sz[u]) ninner[i][j] = inf;
rep(allp, 2) rep(c, S) if (inner[allp][c] != inf) {
rep(uallp, 2) rep(uc, sz[u] + 1) if (dp[u][uallp][uc] != inf) {
chmin(ninner[allp & uallp][c + uc],
inner[allp][c] + dp[u][uallp][uc]);
if (uallp == 1 || dp[u][uallp][uc] < 0) {
chmin(ninner[allp & uallp][c + uc + 1], inner[allp][c]);
}
}
}
rep(i, 2) rep(j, S + sz[u]) inner[i][j] = ninner[i][j];
S += sz[u];
}
rep(i, 2) rep(j, S) dp[v][i][j] = inner[i][j];
}
int main() {
cin >> N;
A.resize(N);
G.resize(N);
sz.resize(N);
rep(i, N) cin >> A[i];
rep(i, N - 1) {
int x, y;
cin >> x >> y;
x--, y--;
G[x].pb(y);
G[y].pb(x);
}
dfs(0, -1);
int ans = N;
rep(allp, 2) rep(c, N) if (dp[0][allp][c] != inf) {
if (allp == 1 || dp[0][allp][c] < 0)
chmin(ans, c);
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define all(c) c.begin(), c.end()
#define pb push_back
#define fs first
#define sc second
#define show(x) cout << #x << " = " << (x) << endl
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
using namespace std;
template <class S, class T>
ostream &operator<<(ostream &o, const pair<S, T> &p) {
return o << "(" << p.fs << "," << p.sc << ")";
}
template <class T> ostream &operator<<(ostream &o, const vector<T> &vc) {
o << "{";
for (const T &v : vc)
o << v << ",";
o << "}";
return o;
}
using ll = long long;
template <class T> using V = vector<T>;
template <class T> using VV = vector<vector<T>>;
int N;
V<ll> A;
VV<int> G;
V<int> sz;
ll dp[5010][2][5010];
ll inner[2][5010];
ll ninner[2][5010];
ll inf = 1e18;
void dfs(int v, int p) {
sz[v] = 1;
for (int u : G[v])
if (u != p)
dfs(u, v), sz[v] += sz[u];
int S = 1;
inner[0][0] = inner[1][0] = A[v];
if (A[v] < 0)
inner[1][0] = inf;
for (int u : G[v])
if (u != p) {
rep(i, 2) rep(j, S + sz[u]) ninner[i][j] = inf;
rep(allp, 2) rep(c, S) if (inner[allp][c] != inf) {
rep(uallp, 2) rep(uc, sz[u] + 1) if (dp[u][uallp][uc] != inf) {
chmin(ninner[allp & uallp][c + uc],
inner[allp][c] + dp[u][uallp][uc]);
if (uallp == 1 || dp[u][uallp][uc] < 0) {
chmin(ninner[allp][c + uc + 1], inner[allp][c]);
}
}
}
rep(i, 2) rep(j, S + sz[u]) inner[i][j] = ninner[i][j];
S += sz[u];
}
rep(i, 2) rep(j, S) dp[v][i][j] = inner[i][j];
}
int main() {
cin >> N;
A.resize(N);
G.resize(N);
sz.resize(N);
rep(i, N) cin >> A[i];
rep(i, N - 1) {
int x, y;
cin >> x >> y;
x--, y--;
G[x].pb(y);
G[y].pb(x);
}
dfs(0, -1);
int ans = N;
rep(allp, 2) rep(c, N) if (dp[0][allp][c] != inf) {
if (allp == 1 || dp[0][allp][c] < 0)
chmin(ans, c);
}
cout << ans << endl;
} | [
"expression.operation.binary.remove"
] | 953,401 | 953,402 | u309470177 | cpp |
p03159 | // https://atcoder.jp/contests/aising2019/tasks/aising2019_e
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
#ifdef BTK
#define DEBUG if (1)
#else
#define CIN_ONLY if (1)
struct cww {
cww() {
CIN_ONLY {
ios::sync_with_stdio(false);
cin.tie(0);
}
}
} star;
#define DEBUG if (0)
#endif
#define ALL(v) (v).begin(), (v).end()
#define REC(ret, ...) std::function<ret(__VA_ARGS__)>
template <typename T> inline bool chmin(T &l, T r) {
bool a = l > r;
if (a)
l = r;
return a;
}
template <typename T> inline bool chmax(T &l, T r) {
bool a = l < r;
if (a)
l = r;
return a;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &it : v)
is >> it;
return is;
}
class range {
private:
struct I {
int x;
int operator*() { return x; }
bool operator!=(I &lhs) { return x < lhs.x; }
void operator++() { ++x; }
};
I i, n;
public:
range(int n) : i({0}), n({n}) {}
range(int i, int n) : i({i}), n({n}) {}
I &begin() { return i; }
I &end() { return n; }
};
int N;
LL A[5123];
vector<int> g[5123];
vector<int> t[5123];
LL allB[5123][5123];
LL dp[5123][5123];
LL tmp[5123];
int sub[5123];
void dfs(int v, int p) {
sub[v] = 1;
for (int u : g[v]) {
if (u == p)
continue;
t[v].push_back(u);
dfs(u, v);
sub[v] += sub[u];
}
}
void solve(int v) {
for (int u : t[v]) {
solve(u);
}
int x = 1;
if (A[v] > 0) {
allB[v][0] = 1;
} else {
allB[v][0] = 0;
}
dp[v][0] = A[v];
for (int u : t[v]) {
const int nx = x + sub[u];
for (int i : range(nx + 1)) {
tmp[i] = 0;
}
for (int i : range(x))
for (int j : range(sub[u] + 1)) {
tmp[i + j] |= (allB[v][i] & allB[u][j]);
}
for (int i : range(nx + 1)) {
allB[v][i] = tmp[i];
tmp[i] = 1e18;
}
for (int i : range(x))
for (int j : range(sub[u] + 1)) {
chmin(tmp[i + j], dp[v][i] + dp[u][j]);
}
for (int i : range(nx + 1)) {
dp[v][i] = tmp[i];
}
x += nx;
}
for (int i : range(x)) {
if (allB[v][i] || dp[v][i] < 0) {
chmin(dp[v][i + 1], 0ll);
allB[v][i + 1] = 1;
}
}
}
int main() {
cin >> N;
for (int i : range(N)) {
cin >> A[i + 1];
}
for (int i : range(N - 1)) {
int u, v;
cin >> u >> v;
g[v].push_back(u);
g[u].push_back(v);
}
dfs(1, 1);
return 0;
solve(1);
int ret = N - 1;
for (int i : range(N + 1)) {
if (allB[1][i])
chmin(ret, i);
if (dp[1][i] < 0)
chmin(ret, i);
}
cout << ret << endl;
return 0;
} | // https://atcoder.jp/contests/aising2019/tasks/aising2019_e
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
#ifdef BTK
#define DEBUG if (1)
#else
#define CIN_ONLY if (1)
struct cww {
cww() {
CIN_ONLY {
ios::sync_with_stdio(false);
cin.tie(0);
}
}
} star;
#define DEBUG if (0)
#endif
#define ALL(v) (v).begin(), (v).end()
#define REC(ret, ...) std::function<ret(__VA_ARGS__)>
template <typename T> inline bool chmin(T &l, T r) {
bool a = l > r;
if (a)
l = r;
return a;
}
template <typename T> inline bool chmax(T &l, T r) {
bool a = l < r;
if (a)
l = r;
return a;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &it : v)
is >> it;
return is;
}
class range {
private:
struct I {
int x;
int operator*() { return x; }
bool operator!=(I &lhs) { return x < lhs.x; }
void operator++() { ++x; }
};
I i, n;
public:
range(int n) : i({0}), n({n}) {}
range(int i, int n) : i({i}), n({n}) {}
I &begin() { return i; }
I &end() { return n; }
};
int N;
LL A[5123];
vector<int> g[5123];
vector<int> t[5123];
LL allB[5123][5123];
LL dp[5123][5123];
LL tmp[5123];
int sub[5123];
void dfs(int v, int p) {
sub[v] = 1;
for (int u : g[v]) {
if (u == p)
continue;
t[v].push_back(u);
dfs(u, v);
sub[v] += sub[u];
}
}
void solve(int v) {
for (int u : t[v]) {
solve(u);
}
int x = 1;
if (A[v] > 0) {
allB[v][0] = 1;
} else {
allB[v][0] = 0;
}
dp[v][0] = A[v];
for (int u : t[v]) {
const int nx = x + sub[u];
for (int i : range(nx + 1)) {
tmp[i] = 0;
}
for (int i : range(x))
for (int j : range(sub[u] + 1)) {
tmp[i + j] |= (allB[v][i] & allB[u][j]);
}
for (int i : range(nx + 1)) {
allB[v][i] = tmp[i];
tmp[i] = 1e18;
}
for (int i : range(x))
for (int j : range(sub[u] + 1)) {
chmin(tmp[i + j], dp[v][i] + dp[u][j]);
}
for (int i : range(nx + 1)) {
dp[v][i] = tmp[i];
}
x = nx;
}
for (int i : range(x)) {
if (allB[v][i] || dp[v][i] < 0) {
chmin(dp[v][i + 1], 0ll);
allB[v][i + 1] = 1;
}
}
}
int main() {
cin >> N;
for (int i : range(N)) {
cin >> A[i + 1];
}
for (int i : range(N - 1)) {
int u, v;
cin >> u >> v;
g[v].push_back(u);
g[u].push_back(v);
}
dfs(1, 1);
solve(1);
int ret = N - 1;
for (int i : range(N + 1)) {
if (allB[1][i])
chmin(ret, i);
if (dp[1][i] < 0)
chmin(ret, i);
}
cout << ret << endl;
return 0;
} | [
"assignment.value.change"
] | 953,407 | 953,408 | u613658617 | cpp |
p03159 | #include <bits/stdc++.h>
#define INF (1LL << 60)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int n;
ll a[5005];
ll a2[5005];
vector<int> G[5005];
vector<int> G2[5005];
int cmp[5005];
ll dp[5005][5005][2];
int sz[5005];
int cnt2[5005];
void dfs(int v, int c) {
cmp[v] = c;
if (a[v] < 0LL)
return;
for (int i = 0; i < G[v].size(); i++) {
int nv = G[v][i];
if (a[nv] > 0LL && cmp[nv] == -1) {
dfs(nv, c);
}
}
}
int dfs2(int v, int p) {
sz[v] = 1;
for (int i = 0; i < G[v].size(); i++) {
int nv = G[v][i];
if (nv != p) {
sz[v] += dfs2(nv, v);
}
}
return sz[v];
}
ll tmp[5005][2];
void dfs3(int v, int p) {
int szc = 1;
if (a[v] < 0LL)
dp[v][0][1] = a[v];
else
dp[v][0][0] = a[v];
cnt2[v]++;
assert(cnt2[v] == 1);
for (int i = 0; i < G[v].size(); i++) {
int nv = G[v][i];
if (nv == p)
continue;
dfs3(nv, v);
for (int j = 0; j <= szc + sz[nv]; j++) {
tmp[j][0] = INF;
tmp[j][1] = INF;
}
for (int j = 0; j < szc; j++) {
for (int k = 0; k < sz[nv]; k++) {
tmp[j + k][0] = min(tmp[j + k][0], dp[v][j][0] + dp[nv][k][0]);
tmp[j + k][1] = min(tmp[j + k][1], dp[v][j][1] + dp[nv][k][0]);
tmp[j + k][1] = min(tmp[j + k][1], dp[v][j][0] + dp[nv][k][1]);
tmp[j + k][1] = min(tmp[j + k][1], dp[v][j][1] + dp[nv][k][1]);
if (dp[nv][k][1] < 0LL || dp[nv][k][0] != INF)
tmp[j + k + 1][1] = min(tmp[j + k + 1][1], dp[v][j][1]);
if (dp[nv][k][1] < 0LL || dp[nv][k][0] != INF)
tmp[j + k + 1][0] = min(tmp[j + k + 1][0], dp[v][j][0]);
}
}
for (int j = 0; j <= szc + sz[nv]; j++) {
dp[v][j][0] = tmp[j][0];
dp[v][j][1] = tmp[j][1];
}
szc += sz[nv];
}
/*
printf("%d\n",v);
for(int i=0;i<=szc;i++){
printf("%lld %lld\n",dp[v][i][0],dp[v][i][1]);
}
*/
}
int main(void) {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
}
for (int i = 0; i < n - 1; i++) {
int u, v;
scanf("%d%d", &u, &v);
u--;
v--;
G[u].push_back(v);
G[v].push_back(u);
}
memset(cmp, -1, sizeof(cmp));
int sz = 0;
for (int i = 0; i < n; i++) {
if (cmp[i] == -1) {
dfs(i, sz++);
}
// printf("%d ",cmp[i]);
}
// printf("\n");
for (int i = 0; i < n; i++) {
a2[cmp[i]] += a[i];
for (int j = 0; j < G[i].size(); j++) {
int nv = cmp[G[i][j]];
if (nv != cmp[i]) {
G2[cmp[i]].push_back(nv);
G2[nv].push_back(cmp[i]);
}
}
}
for (int i = 0; i < sz; i++) {
sort(G2[i].begin(), G2[i].end());
G2[i].erase(unique(G2[i].begin(), G2[i].end()), G2[i].end());
}
dfs2(0, -1);
for (int i = 0; i <= sz; i++) {
for (int j = 0; j <= sz; j++) {
for (int k = 0; k < 2; k++) {
dp[i][j][k] = 1LL << 60;
}
}
}
dfs3(0, -1);
int ans = n - 1;
for (int i = 0; i < n; i++) {
if (dp[0][i][0] < 0LL || dp[0][i][1] < 0LL)
ans = min(ans, i);
if (dp[0][i][0] != INF)
ans = min(ans, i);
}
printf("%d\n", ans);
return 0;
} | #include <bits/stdc++.h>
#define INF (1LL << 60)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int n;
ll a[5005];
ll a2[5005];
vector<int> G[5005];
vector<int> G2[5005];
int cmp[5005];
ll dp[5005][5005][2];
int sz[5005];
int cnt2[5005];
void dfs(int v, int c) {
cmp[v] = c;
if (a[v] < 0LL)
return;
for (int i = 0; i < G[v].size(); i++) {
int nv = G[v][i];
if (a[nv] > 0LL && cmp[nv] == -1) {
dfs(nv, c);
}
}
}
int dfs2(int v, int p) {
sz[v] = 1;
for (int i = 0; i < G[v].size(); i++) {
int nv = G[v][i];
if (nv != p) {
sz[v] += dfs2(nv, v);
}
}
return sz[v];
}
ll tmp[5005][2];
void dfs3(int v, int p) {
int szc = 1;
if (a[v] < 0LL)
dp[v][0][1] = a[v];
else
dp[v][0][0] = a[v];
cnt2[v]++;
assert(cnt2[v] == 1);
for (int i = 0; i < G[v].size(); i++) {
int nv = G[v][i];
if (nv == p)
continue;
dfs3(nv, v);
for (int j = 0; j <= szc + sz[nv]; j++) {
tmp[j][0] = INF;
tmp[j][1] = INF;
}
for (int j = 0; j < szc; j++) {
for (int k = 0; k < sz[nv]; k++) {
tmp[j + k][0] = min(tmp[j + k][0], dp[v][j][0] + dp[nv][k][0]);
tmp[j + k][1] = min(tmp[j + k][1], dp[v][j][1] + dp[nv][k][0]);
tmp[j + k][1] = min(tmp[j + k][1], dp[v][j][0] + dp[nv][k][1]);
tmp[j + k][1] = min(tmp[j + k][1], dp[v][j][1] + dp[nv][k][1]);
if (dp[nv][k][1] < 0LL || dp[nv][k][0] != INF)
tmp[j + k + 1][1] = min(tmp[j + k + 1][1], dp[v][j][1]);
if (dp[nv][k][1] < 0LL || dp[nv][k][0] != INF)
tmp[j + k + 1][0] = min(tmp[j + k + 1][0], dp[v][j][0]);
}
}
for (int j = 0; j <= szc + sz[nv]; j++) {
dp[v][j][0] = tmp[j][0];
dp[v][j][1] = tmp[j][1];
}
szc += sz[nv];
}
/*
printf("%d\n",v);
for(int i=0;i<=szc;i++){
printf("%lld %lld\n",dp[v][i][0],dp[v][i][1]);
}
*/
}
int main(void) {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
}
for (int i = 0; i < n - 1; i++) {
int u, v;
scanf("%d%d", &u, &v);
u--;
v--;
G[u].push_back(v);
G[v].push_back(u);
}
memset(cmp, -1, sizeof(cmp));
int sz = 0;
for (int i = 0; i < n; i++) {
if (cmp[i] == -1) {
dfs(i, sz++);
}
// printf("%d ",cmp[i]);
}
// printf("\n");
for (int i = 0; i < n; i++) {
a2[cmp[i]] += a[i];
for (int j = 0; j < G[i].size(); j++) {
int nv = cmp[G[i][j]];
if (nv != cmp[i]) {
G2[cmp[i]].push_back(nv);
G2[nv].push_back(cmp[i]);
}
}
}
for (int i = 0; i < sz; i++) {
sort(G2[i].begin(), G2[i].end());
G2[i].erase(unique(G2[i].begin(), G2[i].end()), G2[i].end());
}
dfs2(0, -1);
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
for (int k = 0; k < 2; k++) {
dp[i][j][k] = 1LL << 60;
}
}
}
dfs3(0, -1);
int ans = n - 1;
for (int i = 0; i < n; i++) {
if (dp[0][i][0] < 0LL || dp[0][i][1] < 0LL)
ans = min(ans, i);
if (dp[0][i][0] != INF)
ans = min(ans, i);
}
printf("%d\n", ans);
return 0;
} | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 953,410 | 953,411 | u854869949 | cpp |
p03159 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, N) for (int i = 0; i < (N); i++)
#define all(a) (a).begin(), (a).end()
#define pb push_back
using ll = long long;
using i_i = tuple<int, int>;
int N;
void f(int u, int p, vector<int> &a, vector<vector<int>> &G,
vector<vector<ll>> &dp, vector<vector<ll>> &ep) {
dp[u] = vector<ll>{a[u]};
ep[u] = vector<ll>{a[u]};
for (int v : G[u])
if (v != p) {
f(v, u, a, G, dp, ep);
int n = dp[u].size();
int m = dp[v].size();
vector<ll> unko(n + m - 1, LLONG_MAX / 10);
vector<ll> hoge(n + m - 1, LLONG_MAX / 10);
rep(i, n) rep(j, m) {
unko[i + j] = min(unko[i + j], dp[u][i] + dp[v][j]);
hoge[i + j] = min(hoge[i + j], ep[u][i] + ep[v][j]);
}
dp[u] = unko;
ep[u] = hoge;
}
if (a[u] < 0)
rep(i, ep[u].size()) ep[u][i] = LLONG_MAX / 10;
dp[u].pb(LLONG_MAX / 10);
ep[u].pb(LLONG_MAX / 10);
for (int i = (int)dp[u].size() - 2; i >= 0; i--) {
if (dp[u][i] < 0 || ep[u][i] < LLONG_MAX / 100) {
dp[u][i + 1] = min(dp[u][i + 1], 0LL);
ep[u][i + 1] = min(ep[u][i + 1], 0LL);
}
}
}
int main() {
cin >> N;
vector<int> a(N);
rep(u, N) cin >> a[u];
vector<vector<int>> G(N);
rep(i, N - 1) {
int u, v;
cin >> u >> v;
u--;
v--;
G[u].pb(v);
G[v].pb(u);
}
vector<vector<ll>> dp(N), ep(N);
f(0, -1, a, G, dp, ep);
int ans = N;
rep(i, dp[0].size()) if (dp[0][i] <= 0 || ep[0][i] < LLONG_MAX / 100) ans =
min(ans, i);
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, N) for (int i = 0; i < (N); i++)
#define all(a) (a).begin(), (a).end()
#define pb push_back
using ll = long long;
using i_i = tuple<int, int>;
int N;
void f(int u, int p, vector<int> &a, vector<vector<int>> &G,
vector<vector<ll>> &dp, vector<vector<ll>> &ep) {
dp[u] = vector<ll>{a[u]};
ep[u] = vector<ll>{a[u]};
for (int v : G[u])
if (v != p) {
f(v, u, a, G, dp, ep);
int n = dp[u].size();
int m = dp[v].size();
vector<ll> unko(n + m - 1, LLONG_MAX / 10);
vector<ll> hoge(n + m - 1, LLONG_MAX / 10);
rep(i, n) rep(j, m) {
unko[i + j] = min(unko[i + j], dp[u][i] + dp[v][j]);
hoge[i + j] = min(hoge[i + j], ep[u][i] + ep[v][j]);
}
dp[u] = unko;
ep[u] = hoge;
}
if (a[u] < 0)
rep(i, ep[u].size()) ep[u][i] = LLONG_MAX / 10;
dp[u].pb(LLONG_MAX / 10);
ep[u].pb(LLONG_MAX / 10);
for (int i = (int)dp[u].size() - 2; i >= 0; i--) {
if (dp[u][i] < 0 || ep[u][i] < LLONG_MAX / 100) {
dp[u][i + 1] = min(dp[u][i + 1], 0LL);
ep[u][i + 1] = min(ep[u][i + 1], 0LL);
}
}
}
int main() {
cin >> N;
vector<int> a(N);
rep(u, N) cin >> a[u];
vector<vector<int>> G(N);
rep(i, N - 1) {
int u, v;
cin >> u >> v;
u--;
v--;
G[u].pb(v);
G[v].pb(u);
}
vector<vector<ll>> dp(N), ep(N);
f(0, -1, a, G, dp, ep);
int ans = N;
rep(i, dp[0].size()) if (dp[0][i] < 0 || ep[0][i] < LLONG_MAX / 100) ans =
min(ans, i);
cout << ans << endl;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 953,412 | 953,413 | u277541046 | cpp |
p03160 | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <map>
#include <queue>
#include <set>
#include <stdio.h>
#include <string>
#include <unordered_map>
#include <vector>
#define ll long long
#define pii pair<int, int>
#define pll pair<long long, long long>
#define plxy pair<long long, pll>
#define INT_MAX 1e18
#define Keep_calm_You_are_still_learning \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
using namespace std;
using namespace std;
const int mod = 1e9 + 7;
const int N = 1e5 + 5;
ll dp[N];
int main() {
ll n, arr[N];
cin >> n;
for (ll i = 0; i < n; i++)
cin >> arr[i];
dp[0] = arr[0];
dp[1] = abs(arr[1] - arr[0]);
for (ll i = 2; i < n; i++) {
dp[i] = min(abs(arr[i] - arr[i - 1]) + dp[i - 1],
abs(arr[i] - arr[i - 2]) + dp[i - 2]);
}
cout << dp[n - 1];
return 0;
}
| #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <map>
#include <queue>
#include <set>
#include <stdio.h>
#include <string>
#include <unordered_map>
#include <vector>
#define ll long long
#define pii pair<int, int>
#define pll pair<long long, long long>
#define plxy pair<long long, pll>
#define INT_MAX 1e18
#define Keep_calm_You_are_still_learning \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
using namespace std;
using namespace std;
const int mod = 1e9 + 7;
const int N = 1e5 + 5;
ll dp[N];
int main() {
ll n, arr[N];
cin >> n;
for (ll i = 0; i < n; i++)
cin >> arr[i];
dp[0] = 0;
dp[1] = abs(arr[1] - arr[0]);
for (ll i = 2; i < n; i++) {
dp[i] = min(abs(arr[i] - arr[i - 1]) + dp[i - 1],
abs(arr[i] - arr[i - 2]) + dp[i - 2]);
}
cout << dp[n - 1];
return 0;
}
| [] | 953,416 | 953,417 | u353919145 | cpp |
p03160 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
int a[1000010];
int f[1000010];
int main(void) {
// freopen("test.in","r",stdin);
// freopen("test.out","w",stdout);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
f[1] = a[1];
f[2] = abs(a[1] - a[2]);
for (int i = 3; i <= n; i++) {
f[i] =
min(f[i - 1] + abs(a[i] - a[i - 1]), f[i - 2] + abs(a[i] - a[i - 2]));
}
cout << f[n] << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
int a[1000010];
int f[1000010];
int main(void) {
// freopen("test.in","r",stdin);
// freopen("test.out","w",stdout);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
f[1] = 0;
f[2] = abs(a[1] - a[2]);
for (int i = 3; i <= n; i++) {
f[i] =
min(f[i - 1] + abs(a[i] - a[i - 1]), f[i - 2] + abs(a[i] - a[i - 2]));
// cout << f[i] << endl;
}
cout << f[n] << endl;
return 0;
}
| [
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add"
] | 953,420 | 953,421 | u353919145 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define FAST \
ios_base ::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define endl '\n'
#define mod 1000000007
int main() {
FAST;
int t;
t = 1;
// cin>>t;
while (t--) {
int n;
cin >> n;
int a[n + 1], dp[n + 1];
for (int i = 1; i <= n; i++)
cin >> a[i];
memset(dp, 0, sizeof(dp));
dp[1] = 0, dp[2] = abs(dp[2] - dp[1]);
for (int i = 3; i <= n; i++) {
dp[i] = min(dp[i - 1] + abs(a[i] - a[i - 1]),
dp[i - 2] + abs(a[i] - a[i - 2]));
}
cout << dp[n] << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define FAST \
ios_base ::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define endl '\n'
#define mod 1000000007
int main() {
FAST;
int t;
t = 1;
// cin>>t;
while (t--) {
int n;
cin >> n;
int a[n + 1], dp[n + 1];
for (int i = 1; i <= n; i++)
cin >> a[i];
memset(dp, 0, sizeof(dp));
dp[1] = 0, dp[2] = abs(a[2] - a[1]);
for (int i = 3; i <= n; i++) {
dp[i] = min(dp[i - 1] + abs(a[i] - a[i - 1]),
dp[i - 2] + abs(a[i] - a[i - 2]));
}
cout << dp[n] << endl;
}
return 0;
} | [
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 953,424 | 953,425 | u572539622 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define pf printf
#define sf(a) scanf("%d", &a)
#define sfl(a) scanf("%lld", &a)
#define sff(a, b) scanf("%d %d", &a, &b)
#define sffl(a, b) scanf("%lld %lld", &a, &b)
#define sfff(a, b, c) scanf("%d %d %d", &a, &b, &c)
#define sfffl(a, b, c) scanf("%lld %lld %lld", &a, &b, &c)
#define sffff(a, b, c, d) scanf("%d %d %d %d", &a, &b, &c, &d)
#define sffffl(a, b, c, d) scanf("%lld %lld %lld %lld", &a, &b, &c, &d)
#define sfffff(a, b, c, d, e) scanf("%d %d %d %d %d", &a, &b, &c, &d, &e)
#define sfffffl(a, b, c, d, e) \
scanf("%lld %lld %lld %lld %lld", &a, &b, &c, &d, &e)
#define sfc(a) scanf("%c", &a)
#define pii pair<int, int>
#define ms(a, b) memset(a, b, sizeof(a))
#define pb(a) push_back(a)
#define pbp(a, b) push_back({a, b})
#define db double
#define ft float
#define ll long long
#define ull unsigned long long
#define pii pair<int, int>
#define ff first
#define ss second
#define sz(x) x.size()
#define all(x) x.begin(), x.end()
#define CIN \
ios_base::sync_with_stdio(0); \
cin.tie(0)
#define max3(a, b, c) max(a, b) > max(b, c) ? max(a, b) : max(b, c)
#define min3(a, b, c) min(a, b) < min(b, c) ? min(a, b) : min(b, c)
#define for0(i, n) for (int i = 0; i < n; i++)
#define for1(i, n) for (int i = 1; i <= n; i++)
#define forrev(i, n) for (int i = n - 1; i >= 0; i--)
#define forab(i, a, b) for (int i = a; i <= b; i++)
#define forba(i, b, a) for (int i = b; i >= a; i--)
#define stlloop(x) for (__typeof(x.begin()) it = x.begin(); it != x.end(); it++)
#define gcd(a, b) __gcd(a, b)
#define lcm(a, b) ((a) * ((b) / gcd(a, b)))
#define case1(z) cout << "Case " << z << ": "
#define case2(z) printf("Case %d: ", z)
#define PI acos(-1) // 3.14159265358979323846264338328
#define valid(tx, ty) tx >= 0 && tx < row &&ty >= 0 && ty < col
#define intlim 2147483648
#define N 100005
#define inf 100000008
#define mod 1000000007
/*------------------------------Graph Moves----------------------------*/
// const int fx[]={+1,-1,+0,+0};
// const int fy[]={+0,+0,+1,-1};
// const int fx[]={+0,+0,+1,-1,-1,+1,-1,+1}; // Kings Move
// const int fy[]={-1,+1,+0,+0,+1,+1,-1,-1}; // Kings Move
// const int fx[]={-2, -2, -1, -1, 1, 1, 2, 2}; // Knights Move
// const int fy[]={-1, 1, -2, 2, -2, 2, -1, 1}; // Knights Move
/*---------------------------------------------------------------------*/
int main() {
ll n, i, x, y;
ll a[N], dp[N];
cin >> n;
for1(i, n) cin >> a[i];
a[0] = 0, dp[0] = 0, dp[1] = abs(a[i] - a[0]);
for (i = 2; i <= n; i++) {
x = abs(a[i] - a[i - 2]);
y = abs(a[i] - a[i - 1]);
dp[i] = min(x + dp[i - 2], y + dp[i - 1]);
// cout<<dp[i]<<endl;
}
cout << dp[n] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define pf printf
#define sf(a) scanf("%d", &a)
#define sfl(a) scanf("%lld", &a)
#define sff(a, b) scanf("%d %d", &a, &b)
#define sffl(a, b) scanf("%lld %lld", &a, &b)
#define sfff(a, b, c) scanf("%d %d %d", &a, &b, &c)
#define sfffl(a, b, c) scanf("%lld %lld %lld", &a, &b, &c)
#define sffff(a, b, c, d) scanf("%d %d %d %d", &a, &b, &c, &d)
#define sffffl(a, b, c, d) scanf("%lld %lld %lld %lld", &a, &b, &c, &d)
#define sfffff(a, b, c, d, e) scanf("%d %d %d %d %d", &a, &b, &c, &d, &e)
#define sfffffl(a, b, c, d, e) \
scanf("%lld %lld %lld %lld %lld", &a, &b, &c, &d, &e)
#define sfc(a) scanf("%c", &a)
#define pii pair<int, int>
#define ms(a, b) memset(a, b, sizeof(a))
#define pb(a) push_back(a)
#define pbp(a, b) push_back({a, b})
#define db double
#define ft float
#define ll long long
#define ull unsigned long long
#define pii pair<int, int>
#define ff first
#define ss second
#define sz(x) x.size()
#define all(x) x.begin(), x.end()
#define CIN \
ios_base::sync_with_stdio(0); \
cin.tie(0)
#define max3(a, b, c) max(a, b) > max(b, c) ? max(a, b) : max(b, c)
#define min3(a, b, c) min(a, b) < min(b, c) ? min(a, b) : min(b, c)
#define for0(i, n) for (int i = 0; i < n; i++)
#define for1(i, n) for (int i = 1; i <= n; i++)
#define forrev(i, n) for (int i = n - 1; i >= 0; i--)
#define forab(i, a, b) for (int i = a; i <= b; i++)
#define forba(i, b, a) for (int i = b; i >= a; i--)
#define stlloop(x) for (__typeof(x.begin()) it = x.begin(); it != x.end(); it++)
#define gcd(a, b) __gcd(a, b)
#define lcm(a, b) ((a) * ((b) / gcd(a, b)))
#define case1(z) cout << "Case " << z << ": "
#define case2(z) printf("Case %d: ", z)
#define PI acos(-1) // 3.14159265358979323846264338328
#define valid(tx, ty) tx >= 0 && tx < row &&ty >= 0 && ty < col
#define intlim 2147483648
#define N 100005
#define inf 100000008
#define mod 1000000007
/*------------------------------Graph Moves----------------------------*/
// const int fx[]={+1,-1,+0,+0};
// const int fy[]={+0,+0,+1,-1};
// const int fx[]={+0,+0,+1,-1,-1,+1,-1,+1}; // Kings Move
// const int fy[]={-1,+1,+0,+0,+1,+1,-1,-1}; // Kings Move
// const int fx[]={-2, -2, -1, -1, 1, 1, 2, 2}; // Knights Move
// const int fy[]={-1, 1, -2, 2, -2, 2, -1, 1}; // Knights Move
/*---------------------------------------------------------------------*/
int main() {
ll n, i, x, y;
ll a[N], dp[N];
cin >> n;
for1(i, n) cin >> a[i];
a[0] = 0, dp[1] = 0, dp[2] = abs(a[2] - a[1]);
for (i = 3; i <= n; i++) {
x = abs(a[i] - a[i - 2]);
y = abs(a[i] - a[i - 1]);
dp[i] = min(x + dp[i - 2], y + dp[i - 1]);
// cout<<dp[i]<<endl;
}
cout << dp[n] << endl;
return 0;
}
| [
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change",
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 953,431 | 953,432 | u018679195 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> vec(N), dp(N);
for (int i = 0; i < N; i++) {
cin >> vec[i];
}
dp[0] = vec[0], dp[1] = abs(vec[1] - vec[0]);
for (int i = 2; i < N; i++) {
dp[i] = min(dp[i - 2] + abs(vec[i] - vec[i - 2]),
dp[i - 1] + abs(vec[i] - vec[i - 1]));
}
cout << dp[N - 1] << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> vec(N), dp(N);
for (int i = 0; i < N; i++) {
cin >> vec[i];
}
dp[0] = 0, dp[1] = abs(vec[1] - vec[0]);
for (int i = 2; i < N; i++) {
dp[i] = min(dp[i - 2] + abs(vec[i] - vec[i - 2]),
dp[i - 1] + abs(vec[i] - vec[i - 1]));
}
cout << dp[N - 1] << endl;
}
| [] | 953,433 | 953,434 | u187772564 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> vec(N), dp(N);
for (int i = 0; i < N; i++) {
cin >> vec[i];
}
dp[0] = vec[0], dp[1] = abs(vec[1] - vec[0]);
for (int i = 2; i < N; i++) {
dp[i + 1] = min(dp[i - 2] + abs(vec[i] - vec[i - 2]),
dp[i - 1] + abs(vec[i] - vec[i - 1]));
}
cout << dp[N - 1] << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> vec(N), dp(N);
for (int i = 0; i < N; i++) {
cin >> vec[i];
}
dp[0] = 0, dp[1] = abs(vec[1] - vec[0]);
for (int i = 2; i < N; i++) {
dp[i] = min(dp[i - 2] + abs(vec[i] - vec[i - 2]),
dp[i - 1] + abs(vec[i] - vec[i - 1]));
}
cout << dp[N - 1] << endl;
}
| [
"expression.operation.binary.remove"
] | 953,435 | 953,434 | u187772564 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define F first
#define S second
#define PB push_back
#define MP make_pair
#define lc 2 * v
#define rc 2 * v + 1
#define mid (s + e) / 2
#define ll long long
#define int long long
#define ld long double
#define pii pair<int, int>
#define pll pair<long long, long long>
#define FAST \
ios::sync_with_stdio(false); \
cin.tie(0);
// #pragma GCC optimize("Ofast")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,avx,avx2")
const int maxn = 130, N = 1e5 + 5, SQ = 600, base = 1999, mod = 1e9 + 7,
INF = 1e18, lg = 17;
int n, a[maxn], dp[maxn];
int32_t main() {
FAST cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
fill(dp, dp + maxn, INF);
dp[0] = 0;
for (int i = 0; i < n; ++i) {
if (i - 1 >= 0) {
dp[i] = min(dp[i], dp[i - 1] + abs(a[i] - a[i - 1]));
}
if (i - 2 >= 0) {
dp[i] = min(dp[i], dp[i - 2] + abs(a[i] - a[i - 2]));
}
}
cout << dp[n - 1] << '\n';
}
| #include <bits/stdc++.h>
using namespace std;
#define F first
#define S second
#define PB push_back
#define MP make_pair
#define lc 2 * v
#define rc 2 * v + 1
#define mid (s + e) / 2
#define ll long long
#define int long long
#define ld long double
#define pii pair<int, int>
#define pll pair<long long, long long>
#define FAST \
ios::sync_with_stdio(false); \
cin.tie(0);
// #pragma GCC optimize("Ofast")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,avx,avx2")
const int maxn = 3e5, N = 1e5 + 5, SQ = 600, base = 1999, mod = 1e9 + 7,
INF = 1e18, lg = 17;
int n, a[maxn], dp[maxn];
int32_t main() {
FAST cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
fill(dp, dp + maxn, INF);
dp[0] = 0;
for (int i = 0; i < n; ++i) {
if (i - 1 >= 0) {
dp[i] = min(dp[i], dp[i - 1] + abs(a[i] - a[i - 1]));
}
if (i - 2 >= 0) {
dp[i] = min(dp[i], dp[i - 2] + abs(a[i] - a[i - 2]));
}
}
cout << dp[n - 1] << '\n';
}
| [
"literal.number.change",
"variable_declaration.value.change"
] | 953,438 | 953,439 | u717668588 | cpp |
p03160 | #include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
int calcCost(int N, vector<int> heights) {
// init dp array
vector<int> dp(N, 0);
dp[0] = 0;
dp[1] = abs(heights[1] - heights[0]);
if (N == 2) {
return dp[1];
}
int cost;
int firstJump;
int secondJump;
for (int i = 2; i <= N; i++) {
firstJump = abs(heights[i] - heights[i - 1]);
secondJump = abs(heights[i] - heights[i - 2]);
cost = min(firstJump + dp[i - 1], secondJump + dp[i - 2]);
dp[i] = cost;
}
return dp[N - 1];
}
int main() {
int numStones;
int height;
cin >> numStones;
if (numStones < 2 || numStones > 100000) {
cout << 0;
return 0;
}
vector<int> heights(numStones + 1, -1);
// cout << numStones << "\n";
for (int i = 0; i < numStones; i++) {
cin >> height;
heights[i] = height;
// printf("enter\n");
// heights.insert(heights.end(), height);
// printf("exit\n");
}
// for (int i = 0; i < numStones; i++) {
// cout << heights[i];
// }
int cost = calcCost(numStones, heights);
cout << cost;
return 0;
} | #include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
int calcCost(int N, vector<int> heights) {
// cout << "here\n";
// init dp array
vector<int> dp(N, 0);
dp[0] = 0;
dp[1] = abs(heights[1] - heights[0]);
if (N == 2) {
return dp[1];
}
int cost;
int firstJump;
int secondJump;
for (int i = 2; i < N; i++) {
firstJump = abs(heights[i] - heights[i - 1]);
secondJump = abs(heights[i] - heights[i - 2]);
cost = min(firstJump + dp[i - 1], secondJump + dp[i - 2]);
dp[i] = cost;
}
return dp[N - 1];
}
int main() {
int numStones;
int height;
cin >> numStones;
if (numStones < 2 || numStones > 100000) {
cout << 0;
return 0;
}
vector<int> heights(numStones + 1, -1);
// cout << numStones << "\n";
for (int i = 0; i < numStones; i++) {
cin >> height;
heights[i] = (int)height;
// printf("enter\n");
// heights.insert(heights.end(), height);
// printf("exit\n");
}
// for (int i = 0; i < numStones; i++) {
// cout << heights[i];
// }
int cost = calcCost(numStones, heights);
cout << cost;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 953,440 | 953,441 | u623883058 | cpp |
p03160 | #pragma GCC optimize("O3")
#define _GLIBCXX_DEBUG
#include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <string_view>
#include <vector>
using namespace std;
/*----------macros----------*/
// output================
#define endl '\n'
#define fcout(a) cout << fixed << setprecision((int)(a))
// typedef===============
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<ll, ll> Pll;
// const number==========
constexpr ll INF9 = (ll)1e9 + 1;
constexpr ll INF18 = (ll)1e18 + 1;
constexpr ll MOD = 1'000'000'007;
constexpr ll MOD2 = 998'244'353;
constexpr ld PI = 3.141592653589793L;
// member================
#define pb push_back
#define eb emplace_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
// others================
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define rep(i, n) for (int i = 0; (i) < (n); ++(i))
#define reps(i, n) for (int i = 1; (i) <= (n); ++(i))
#define rrep(i, n) for (int i = n - 1; (i) >= 0; --(i))
#define CtoI(c) int((c)) - int('0')
#define ItoC(c) char((c) + '0')
// functions=============
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
// vector<int> dx = {1, 0, -1, 0}, dy = {0, 1, 0, -1};
// vector<int> dx2 = { 1,1,0,-1,-1,-1,0,1 }, dy2 = { 0,1,1,1,0,-1,-1,-1 };
/*--------additional--------*/
/*----------main------------*/
int main() {
/*----------fastio----------*/
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::ios::sync_with_stdio(false);
/*----------solve-----------*/
int n;
cin >> n;
vector<int> h(n);
rep(i, n) cin >> h[i];
int dp[n + 5];
dp[1] = abs(h[1] - h[0]);
for (int i = 2; i < n; ++i) {
dp[i] =
min(dp[i - 2] + abs(h[i] - h[i - 2]), dp[i - 1] + abs(h[i] - h[i - 1]));
}
cout << dp[n - 1] << endl;
return 0;
}
| #pragma GCC optimize("O3")
#define _GLIBCXX_DEBUG
#include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <string_view>
#include <vector>
using namespace std;
/*----------macros----------*/
// output================
#define endl '\n'
#define fcout(a) cout << fixed << setprecision((int)(a))
// typedef===============
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<ll, ll> Pll;
// const number==========
constexpr ll INF9 = (ll)1e9 + 1;
constexpr ll INF18 = (ll)1e18 + 1;
constexpr ll MOD = 1'000'000'007;
constexpr ll MOD2 = 998'244'353;
constexpr ld PI = 3.141592653589793L;
// member================
#define pb push_back
#define eb emplace_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
// others================
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define rep(i, n) for (int i = 0; (i) < (n); ++(i))
#define reps(i, n) for (int i = 1; (i) <= (n); ++(i))
#define rrep(i, n) for (int i = n - 1; (i) >= 0; --(i))
#define CtoI(c) int((c)) - int('0')
#define ItoC(c) char((c) + '0')
// functions=============
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
// vector<int> dx = {1, 0, -1, 0}, dy = {0, 1, 0, -1};
// vector<int> dx2 = { 1,1,0,-1,-1,-1,0,1 }, dy2 = { 0,1,1,1,0,-1,-1,-1 };
/*--------additional--------*/
/*----------main------------*/
int main() {
/*----------fastio----------*/
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::ios::sync_with_stdio(false);
/*----------solve-----------*/
int n;
cin >> n;
vector<int> h(n);
rep(i, n) cin >> h[i];
int dp[100000 - 1];
dp[1] = abs(h[1] - h[0]);
for (int i = 2; i < n; ++i) {
dp[i] =
min(dp[i - 2] + abs(h[i] - h[i - 2]), dp[i - 1] + abs(h[i] - h[i - 1]));
}
cout << dp[n - 1] << endl;
return 0;
}
| [] | 953,457 | 953,460 | u884476319 | cpp |
p03160 | #pragma GCC optimize("O3")
#define _GLIBCXX_DEBUG
#include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <string_view>
#include <vector>
using namespace std;
/*----------macros----------*/
// output================
#define endl '\n'
#define fcout(a) cout << fixed << setprecision((int)(a))
// typedef===============
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<ll, ll> Pll;
// const number==========
constexpr ll INF9 = (ll)1e9 + 1;
constexpr ll INF18 = (ll)1e18 + 1;
constexpr ll MOD = 1'000'000'007;
constexpr ll MOD2 = 998'244'353;
constexpr ld PI = 3.141592653589793L;
// member================
#define pb push_back
#define eb emplace_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
// others================
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define rep(i, n) for (int i = 0; (i) < (n); ++(i))
#define reps(i, n) for (int i = 1; (i) <= (n); ++(i))
#define rrep(i, n) for (int i = n - 1; (i) >= 0; --(i))
#define CtoI(c) int((c)) - int('0')
#define ItoC(c) char((c) + '0')
// functions=============
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
// vector<int> dx = {1, 0, -1, 0}, dy = {0, 1, 0, -1};
// vector<int> dx2 = { 1,1,0,-1,-1,-1,0,1 }, dy2 = { 0,1,1,1,0,-1,-1,-1 };
/*--------additional--------*/
/*----------main------------*/
int main() {
/*----------fastio----------*/
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::ios::sync_with_stdio(false);
/*----------solve-----------*/
int n;
cin >> n;
vector<int> h(n);
rep(i, n) cin >> h[i];
int dp[n];
dp[1] = abs(h[1] - h[0]);
for (int i = 2; i < n; ++i) {
dp[i] =
min(dp[i - 2] + abs(h[i] - h[i - 2]), dp[i - 1] + abs(h[i] - h[i - 1]));
}
cout << dp[n - 1] << endl;
return 0;
} | #pragma GCC optimize("O3")
#define _GLIBCXX_DEBUG
#include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <string_view>
#include <vector>
using namespace std;
/*----------macros----------*/
// output================
#define endl '\n'
#define fcout(a) cout << fixed << setprecision((int)(a))
// typedef===============
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<ll, ll> Pll;
// const number==========
constexpr ll INF9 = (ll)1e9 + 1;
constexpr ll INF18 = (ll)1e18 + 1;
constexpr ll MOD = 1'000'000'007;
constexpr ll MOD2 = 998'244'353;
constexpr ld PI = 3.141592653589793L;
// member================
#define pb push_back
#define eb emplace_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
// others================
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define rep(i, n) for (int i = 0; (i) < (n); ++(i))
#define reps(i, n) for (int i = 1; (i) <= (n); ++(i))
#define rrep(i, n) for (int i = n - 1; (i) >= 0; --(i))
#define CtoI(c) int((c)) - int('0')
#define ItoC(c) char((c) + '0')
// functions=============
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
// vector<int> dx = {1, 0, -1, 0}, dy = {0, 1, 0, -1};
// vector<int> dx2 = { 1,1,0,-1,-1,-1,0,1 }, dy2 = { 0,1,1,1,0,-1,-1,-1 };
/*--------additional--------*/
/*----------main------------*/
int main() {
/*----------fastio----------*/
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::ios::sync_with_stdio(false);
/*----------solve-----------*/
int n;
cin >> n;
vector<int> h(n);
rep(i, n) cin >> h[i];
int dp[100000 - 1];
dp[1] = abs(h[1] - h[0]);
for (int i = 2; i < n; ++i) {
dp[i] =
min(dp[i - 2] + abs(h[i] - h[i - 2]), dp[i - 1] + abs(h[i] - h[i - 1]));
}
cout << dp[n - 1] << endl;
return 0;
}
| [
"identifier.replace.remove",
"literal.replace.add"
] | 953,459 | 953,460 | u884476319 | cpp |
p03160 | #pragma GCC optimize("O3")
#define _GLIBCXX_DEBUG
#include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <string_view>
#include <vector>
using namespace std;
/*----------macros----------*/
// output================
#define endl '\n'
#define fcout(a) cout << fixed << setprecision((int)(a))
// typedef===============
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<ll, ll> Pll;
// const number==========
constexpr ll INF9 = (ll)1e9 + 1;
constexpr ll INF18 = (ll)1e18 + 1;
constexpr ll MOD = 1'000'000'007;
constexpr ll MOD2 = 998'244'353;
constexpr ld PI = 3.141592653589793L;
// member================
#define pb push_back
#define eb emplace_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
// others================
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define rep(i, n) for (int i = 0; (i) < (n); ++(i))
#define reps(i, n) for (int i = 1; (i) <= (n); ++(i))
#define rrep(i, n) for (int i = n - 1; (i) >= 0; --(i))
#define CtoI(c) int((c)) - int('0')
#define ItoC(c) char((c) + '0')
// functions=============
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
// vector<int> dx = {1, 0, -1, 0}, dy = {0, 1, 0, -1};
// vector<int> dx2 = { 1,1,0,-1,-1,-1,0,1 }, dy2 = { 0,1,1,1,0,-1,-1,-1 };
/*--------additional--------*/
/*----------main------------*/
int main() {
/*----------fastio----------*/
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::ios::sync_with_stdio(false);
/*----------solve-----------*/
int n;
cin >> n;
vector<int> h(n);
rep(i, n) cin >> h[i];
int dp[n + 5];
dp[1] = abs(h[1] - h[0]);
for (int i = 2; i < n; ++i) {
dp[i] =
min(dp[i - 2] + abs(h[i] - h[i - 2]), dp[i - 1] + abs(h[i] - h[i - 1]));
}
cout << dp[n - 1] << endl;
return 0;
}
| #pragma GCC optimize("O3")
#define _GLIBCXX_DEBUG
#include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <string_view>
#include <vector>
using namespace std;
/*----------macros----------*/
// output================
#define endl '\n'
#define fcout(a) cout << fixed << setprecision((int)(a))
// typedef===============
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<ll, ll> Pll;
// const number==========
constexpr ll INF9 = (ll)1e9 + 1;
constexpr ll INF18 = (ll)1e18 + 1;
constexpr ll MOD = 1'000'000'007;
constexpr ll MOD2 = 998'244'353;
constexpr ld PI = 3.141592653589793L;
// member================
#define pb push_back
#define eb emplace_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
// others================
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define rep(i, n) for (int i = 0; (i) < (n); ++(i))
#define reps(i, n) for (int i = 1; (i) <= (n); ++(i))
#define rrep(i, n) for (int i = n - 1; (i) >= 0; --(i))
#define CtoI(c) int((c)) - int('0')
#define ItoC(c) char((c) + '0')
// functions=============
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
// vector<int> dx = {1, 0, -1, 0}, dy = {0, 1, 0, -1};
// vector<int> dx2 = { 1,1,0,-1,-1,-1,0,1 }, dy2 = { 0,1,1,1,0,-1,-1,-1 };
/*--------additional--------*/
/*----------main------------*/
int main() {
/*----------fastio----------*/
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::ios::sync_with_stdio(false);
/*----------solve-----------*/
int n;
cin >> n;
vector<int> h(n);
rep(i, n) cin >> h[i];
int dp[100000];
dp[1] = abs(h[1] - h[0]);
for (int i = 2; i < n; ++i) {
dp[i] =
min(dp[i - 2] + abs(h[i] - h[i - 2]), dp[i - 1] + abs(h[i] - h[i - 1]));
}
cout << dp[n - 1] << endl;
return 0;
}
| [
"identifier.replace.remove",
"literal.replace.add",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 953,457 | 953,461 | u884476319 | cpp |
p03160 | #pragma GCC optimize("O3")
#define _GLIBCXX_DEBUG
#include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <string_view>
#include <vector>
using namespace std;
/*----------macros----------*/
// output================
#define endl '\n'
#define fcout(a) cout << fixed << setprecision((int)(a))
// typedef===============
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<ll, ll> Pll;
// const number==========
constexpr ll INF9 = (ll)1e9 + 1;
constexpr ll INF18 = (ll)1e18 + 1;
constexpr ll MOD = 1'000'000'007;
constexpr ll MOD2 = 998'244'353;
constexpr ld PI = 3.141592653589793L;
// member================
#define pb push_back
#define eb emplace_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
// others================
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define rep(i, n) for (int i = 0; (i) < (n); ++(i))
#define reps(i, n) for (int i = 1; (i) <= (n); ++(i))
#define rrep(i, n) for (int i = n - 1; (i) >= 0; --(i))
#define CtoI(c) int((c)) - int('0')
#define ItoC(c) char((c) + '0')
// functions=============
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
// vector<int> dx = {1, 0, -1, 0}, dy = {0, 1, 0, -1};
// vector<int> dx2 = { 1,1,0,-1,-1,-1,0,1 }, dy2 = { 0,1,1,1,0,-1,-1,-1 };
/*--------additional--------*/
/*----------main------------*/
int main() {
/*----------fastio----------*/
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::ios::sync_with_stdio(false);
/*----------solve-----------*/
int n;
cin >> n;
vector<int> h(n);
rep(i, n) cin >> h[i];
int dp[n];
dp[1] = abs(h[1] - h[0]);
for (int i = 2; i < n; ++i) {
dp[i] =
min(dp[i - 2] + abs(h[i] - h[i - 2]), dp[i - 1] + abs(h[i] - h[i - 1]));
}
cout << dp[n - 1] << endl;
return 0;
} | #pragma GCC optimize("O3")
#define _GLIBCXX_DEBUG
#include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <string_view>
#include <vector>
using namespace std;
/*----------macros----------*/
// output================
#define endl '\n'
#define fcout(a) cout << fixed << setprecision((int)(a))
// typedef===============
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<ll, ll> Pll;
// const number==========
constexpr ll INF9 = (ll)1e9 + 1;
constexpr ll INF18 = (ll)1e18 + 1;
constexpr ll MOD = 1'000'000'007;
constexpr ll MOD2 = 998'244'353;
constexpr ld PI = 3.141592653589793L;
// member================
#define pb push_back
#define eb emplace_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
// others================
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define rep(i, n) for (int i = 0; (i) < (n); ++(i))
#define reps(i, n) for (int i = 1; (i) <= (n); ++(i))
#define rrep(i, n) for (int i = n - 1; (i) >= 0; --(i))
#define CtoI(c) int((c)) - int('0')
#define ItoC(c) char((c) + '0')
// functions=============
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
// vector<int> dx = {1, 0, -1, 0}, dy = {0, 1, 0, -1};
// vector<int> dx2 = { 1,1,0,-1,-1,-1,0,1 }, dy2 = { 0,1,1,1,0,-1,-1,-1 };
/*--------additional--------*/
/*----------main------------*/
int main() {
/*----------fastio----------*/
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::ios::sync_with_stdio(false);
/*----------solve-----------*/
int n;
cin >> n;
vector<int> h(n);
rep(i, n) cin >> h[i];
int dp[100000];
dp[1] = abs(h[1] - h[0]);
for (int i = 2; i < n; ++i) {
dp[i] =
min(dp[i - 2] + abs(h[i] - h[i - 2]), dp[i - 1] + abs(h[i] - h[i - 1]));
}
cout << dp[n - 1] << endl;
return 0;
}
| [
"identifier.replace.remove",
"literal.replace.add",
"variable_declaration.array_dimensions.change"
] | 953,459 | 953,461 | u884476319 | cpp |
p03160 | #pragma GCC optimize("O3")
#define _GLIBCXX_DEBUG
#include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <string_view>
#include <vector>
using namespace std;
/*----------macros----------*/
// output================
#define endl '\n'
#define fcout(a) cout << fixed << setprecision((int)(a))
// typedef===============
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<ll, ll> Pll;
// const number==========
constexpr ll INF9 = (ll)1e9 + 1;
constexpr ll INF18 = (ll)1e18 + 1;
constexpr ll MOD = 1'000'000'007;
constexpr ll MOD2 = 998'244'353;
constexpr ld PI = 3.141592653589793L;
// member================
#define pb push_back
#define eb emplace_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
// others================
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define rep(i, n) for (int i = 0; (i) < (n); ++(i))
#define reps(i, n) for (int i = 1; (i) <= (n); ++(i))
#define rrep(i, n) for (int i = n - 1; (i) >= 0; --(i))
#define CtoI(c) int((c)) - int('0')
#define ItoC(c) char((c) + '0')
// functions=============
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
// vector<int> dx = {1, 0, -1, 0}, dy = {0, 1, 0, -1};
// vector<int> dx2 = { 1,1,0,-1,-1,-1,0,1 }, dy2 = { 0,1,1,1,0,-1,-1,-1 };
/*--------additional--------*/
/*----------main------------*/
int main() {
/*----------fastio----------*/
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::ios::sync_with_stdio(false);
/*----------solve-----------*/
int n;
cin >> n;
vector<int> h(n);
rep(i, n) cin >> h[i];
int dp[n + 5];
dp[1] = abs(h[1] - h[0]);
for (int i = 2; i < n; ++i) {
dp[i] =
min(dp[i - 2] + abs(h[i] - h[i - 2]), dp[i - 1] + abs(h[i] - h[i - 1]));
}
cout << dp[n - 1] << endl;
return 0;
}
| #pragma GCC optimize("O3")
#define _GLIBCXX_DEBUG
#include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <string_view>
#include <vector>
using namespace std;
/*----------macros----------*/
// output================
#define endl '\n'
#define fcout(a) cout << fixed << setprecision((int)(a))
// typedef===============
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<ll, ll> Pll;
// const number==========
constexpr ll INF9 = (ll)1e9 + 1;
constexpr ll INF18 = (ll)1e18 + 1;
constexpr ll MOD = 1'000'000'007;
constexpr ll MOD2 = 998'244'353;
constexpr ld PI = 3.141592653589793L;
// member================
#define pb push_back
#define eb emplace_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
// others================
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define rep(i, n) for (int i = 0; (i) < (n); ++(i))
#define reps(i, n) for (int i = 1; (i) <= (n); ++(i))
#define rrep(i, n) for (int i = n - 1; (i) >= 0; --(i))
#define CtoI(c) int((c)) - int('0')
#define ItoC(c) char((c) + '0')
// functions=============
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
// vector<int> dx = {1, 0, -1, 0}, dy = {0, 1, 0, -1};
// vector<int> dx2 = { 1,1,0,-1,-1,-1,0,1 }, dy2 = { 0,1,1,1,0,-1,-1,-1 };
/*--------additional--------*/
/*----------main------------*/
int main() {
/*----------fastio----------*/
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::ios::sync_with_stdio(false);
/*----------solve-----------*/
int n;
cin >> n;
vector<int> h(n);
rep(i, n) cin >> h[i];
int dp[1000000 - 1];
dp[1] = abs(h[1] - h[0]);
for (int i = 2; i < n; ++i) {
dp[i] =
min(dp[i - 2] + abs(h[i] - h[i - 2]), dp[i - 1] + abs(h[i] - h[i - 1]));
}
cout << dp[n - 1] << endl;
return 0;
}
| [] | 953,457 | 953,462 | u884476319 | cpp |
p03160 | #pragma GCC optimize("O3")
#define _GLIBCXX_DEBUG
#include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <string_view>
#include <vector>
using namespace std;
/*----------macros----------*/
// output================
#define endl '\n'
#define fcout(a) cout << fixed << setprecision((int)(a))
// typedef===============
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<ll, ll> Pll;
// const number==========
constexpr ll INF9 = (ll)1e9 + 1;
constexpr ll INF18 = (ll)1e18 + 1;
constexpr ll MOD = 1'000'000'007;
constexpr ll MOD2 = 998'244'353;
constexpr ld PI = 3.141592653589793L;
// member================
#define pb push_back
#define eb emplace_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
// others================
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define rep(i, n) for (int i = 0; (i) < (n); ++(i))
#define reps(i, n) for (int i = 1; (i) <= (n); ++(i))
#define rrep(i, n) for (int i = n - 1; (i) >= 0; --(i))
#define CtoI(c) int((c)) - int('0')
#define ItoC(c) char((c) + '0')
// functions=============
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
// vector<int> dx = {1, 0, -1, 0}, dy = {0, 1, 0, -1};
// vector<int> dx2 = { 1,1,0,-1,-1,-1,0,1 }, dy2 = { 0,1,1,1,0,-1,-1,-1 };
/*--------additional--------*/
/*----------main------------*/
int main() {
/*----------fastio----------*/
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::ios::sync_with_stdio(false);
/*----------solve-----------*/
int n;
cin >> n;
vector<int> h(n);
rep(i, n) cin >> h[i];
int dp[n];
dp[1] = abs(h[1] - h[0]);
for (int i = 2; i < n; ++i) {
dp[i] =
min(dp[i - 2] + abs(h[i] - h[i - 2]), dp[i - 1] + abs(h[i] - h[i - 1]));
}
cout << dp[n - 1] << endl;
return 0;
} | #pragma GCC optimize("O3")
#define _GLIBCXX_DEBUG
#include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <string_view>
#include <vector>
using namespace std;
/*----------macros----------*/
// output================
#define endl '\n'
#define fcout(a) cout << fixed << setprecision((int)(a))
// typedef===============
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<ll, ll> Pll;
// const number==========
constexpr ll INF9 = (ll)1e9 + 1;
constexpr ll INF18 = (ll)1e18 + 1;
constexpr ll MOD = 1'000'000'007;
constexpr ll MOD2 = 998'244'353;
constexpr ld PI = 3.141592653589793L;
// member================
#define pb push_back
#define eb emplace_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
// others================
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define rep(i, n) for (int i = 0; (i) < (n); ++(i))
#define reps(i, n) for (int i = 1; (i) <= (n); ++(i))
#define rrep(i, n) for (int i = n - 1; (i) >= 0; --(i))
#define CtoI(c) int((c)) - int('0')
#define ItoC(c) char((c) + '0')
// functions=============
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
// vector<int> dx = {1, 0, -1, 0}, dy = {0, 1, 0, -1};
// vector<int> dx2 = { 1,1,0,-1,-1,-1,0,1 }, dy2 = { 0,1,1,1,0,-1,-1,-1 };
/*--------additional--------*/
/*----------main------------*/
int main() {
/*----------fastio----------*/
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::ios::sync_with_stdio(false);
/*----------solve-----------*/
int n;
cin >> n;
vector<int> h(n);
rep(i, n) cin >> h[i];
int dp[1000000 - 1];
dp[1] = abs(h[1] - h[0]);
for (int i = 2; i < n; ++i) {
dp[i] =
min(dp[i - 2] + abs(h[i] - h[i - 2]), dp[i - 1] + abs(h[i] - h[i - 1]));
}
cout << dp[n - 1] << endl;
return 0;
}
| [
"identifier.replace.remove",
"literal.replace.add"
] | 953,459 | 953,462 | u884476319 | cpp |
p03160 | #pragma GCC optimize("O3")
#define _GLIBCXX_DEBUG
#include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <string_view>
#include <vector>
using namespace std;
/*----------macros----------*/
// output================
#define endl '\n'
#define fcout(a) cout << fixed << setprecision((int)(a))
// typedef===============
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<ll, ll> Pll;
// const number==========
constexpr ll INF9 = (ll)1e9 + 1;
constexpr ll INF18 = (ll)1e18 + 1;
constexpr ll MOD = 1'000'000'007;
constexpr ll MOD2 = 998'244'353;
constexpr ld PI = 3.141592653589793L;
// member================
#define pb push_back
#define eb emplace_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
// others================
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define rep(i, n) for (int i = 0; (i) < (n); ++(i))
#define reps(i, n) for (int i = 1; (i) <= (n); ++(i))
#define rrep(i, n) for (int i = n - 1; (i) >= 0; --(i))
#define CtoI(c) int((c)) - int('0')
#define ItoC(c) char((c) + '0')
// functions=============
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
// vector<int> dx = {1, 0, -1, 0}, dy = {0, 1, 0, -1};
// vector<int> dx2 = { 1,1,0,-1,-1,-1,0,1 }, dy2 = { 0,1,1,1,0,-1,-1,-1 };
/*--------additional--------*/
/*----------main------------*/
int main() {
/*----------fastio----------*/
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::ios::sync_with_stdio(false);
/*----------solve-----------*/
int n;
cin >> n;
vector<int> h(n);
rep(i, n) cin >> h[i];
int dp[n + 5];
dp[1] = abs(h[1] - h[0]);
for (int i = 2; i < n; ++i) {
dp[i] =
min(dp[i - 2] + abs(h[i] - h[i - 2]), dp[i - 1] + abs(h[i] - h[i - 1]));
}
cout << dp[n - 1] << endl;
return 0;
}
| #pragma GCC optimize("O3")
#define _GLIBCXX_DEBUG
#include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <string_view>
#include <vector>
using namespace std;
/*----------macros----------*/
// output================
#define endl '\n'
#define fcout(a) cout << fixed << setprecision((int)(a))
// typedef===============
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<ll, ll> Pll;
// const number==========
constexpr ll INF9 = (ll)1e9 + 1;
constexpr ll INF18 = (ll)1e18 + 1;
constexpr ll MOD = 1'000'000'007;
constexpr ll MOD2 = 998'244'353;
constexpr ld PI = 3.141592653589793L;
// member================
#define pb push_back
#define eb emplace_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
// others================
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define rep(i, n) for (int i = 0; (i) < (n); ++(i))
#define reps(i, n) for (int i = 1; (i) <= (n); ++(i))
#define rrep(i, n) for (int i = n - 1; (i) >= 0; --(i))
#define CtoI(c) int((c)) - int('0')
#define ItoC(c) char((c) + '0')
// functions=============
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
// vector<int> dx = {1, 0, -1, 0}, dy = {0, 1, 0, -1};
// vector<int> dx2 = { 1,1,0,-1,-1,-1,0,1 }, dy2 = { 0,1,1,1,0,-1,-1,-1 };
/*--------additional--------*/
/*----------main------------*/
int main() {
/*----------fastio----------*/
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::ios::sync_with_stdio(false);
/*----------solve-----------*/
int n;
cin >> n;
vector<int> h(n);
rep(i, n) cin >> h[i];
int dp[1000000];
dp[1] = abs(h[1] - h[0]);
for (int i = 2; i < n; ++i) {
dp[i] =
min(dp[i - 2] + abs(h[i] - h[i - 2]), dp[i - 1] + abs(h[i] - h[i - 1]));
}
cout << dp[n - 1] << endl;
return 0;
}
| [
"identifier.replace.remove",
"literal.replace.add",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 953,457 | 953,463 | u884476319 | cpp |
p03160 | #pragma GCC optimize("O3")
#define _GLIBCXX_DEBUG
#include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <string_view>
#include <vector>
using namespace std;
/*----------macros----------*/
// output================
#define endl '\n'
#define fcout(a) cout << fixed << setprecision((int)(a))
// typedef===============
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<ll, ll> Pll;
// const number==========
constexpr ll INF9 = (ll)1e9 + 1;
constexpr ll INF18 = (ll)1e18 + 1;
constexpr ll MOD = 1'000'000'007;
constexpr ll MOD2 = 998'244'353;
constexpr ld PI = 3.141592653589793L;
// member================
#define pb push_back
#define eb emplace_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
// others================
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define rep(i, n) for (int i = 0; (i) < (n); ++(i))
#define reps(i, n) for (int i = 1; (i) <= (n); ++(i))
#define rrep(i, n) for (int i = n - 1; (i) >= 0; --(i))
#define CtoI(c) int((c)) - int('0')
#define ItoC(c) char((c) + '0')
// functions=============
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
// vector<int> dx = {1, 0, -1, 0}, dy = {0, 1, 0, -1};
// vector<int> dx2 = { 1,1,0,-1,-1,-1,0,1 }, dy2 = { 0,1,1,1,0,-1,-1,-1 };
/*--------additional--------*/
/*----------main------------*/
int main() {
/*----------fastio----------*/
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::ios::sync_with_stdio(false);
/*----------solve-----------*/
int n;
cin >> n;
vector<int> h(n);
rep(i, n) cin >> h[i];
int dp[n];
dp[1] = abs(h[1] - h[0]);
for (int i = 2; i < n; ++i) {
dp[i] =
min(dp[i - 2] + abs(h[i] - h[i - 2]), dp[i - 1] + abs(h[i] - h[i - 1]));
}
cout << dp[n - 1] << endl;
return 0;
} | #pragma GCC optimize("O3")
#define _GLIBCXX_DEBUG
#include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <string_view>
#include <vector>
using namespace std;
/*----------macros----------*/
// output================
#define endl '\n'
#define fcout(a) cout << fixed << setprecision((int)(a))
// typedef===============
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<ll, ll> Pll;
// const number==========
constexpr ll INF9 = (ll)1e9 + 1;
constexpr ll INF18 = (ll)1e18 + 1;
constexpr ll MOD = 1'000'000'007;
constexpr ll MOD2 = 998'244'353;
constexpr ld PI = 3.141592653589793L;
// member================
#define pb push_back
#define eb emplace_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
// others================
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define rep(i, n) for (int i = 0; (i) < (n); ++(i))
#define reps(i, n) for (int i = 1; (i) <= (n); ++(i))
#define rrep(i, n) for (int i = n - 1; (i) >= 0; --(i))
#define CtoI(c) int((c)) - int('0')
#define ItoC(c) char((c) + '0')
// functions=============
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
// vector<int> dx = {1, 0, -1, 0}, dy = {0, 1, 0, -1};
// vector<int> dx2 = { 1,1,0,-1,-1,-1,0,1 }, dy2 = { 0,1,1,1,0,-1,-1,-1 };
/*--------additional--------*/
/*----------main------------*/
int main() {
/*----------fastio----------*/
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::ios::sync_with_stdio(false);
/*----------solve-----------*/
int n;
cin >> n;
vector<int> h(n);
rep(i, n) cin >> h[i];
int dp[1000000];
dp[1] = abs(h[1] - h[0]);
for (int i = 2; i < n; ++i) {
dp[i] =
min(dp[i - 2] + abs(h[i] - h[i - 2]), dp[i - 1] + abs(h[i] - h[i - 1]));
}
cout << dp[n - 1] << endl;
return 0;
}
| [
"identifier.replace.remove",
"literal.replace.add",
"variable_declaration.array_dimensions.change"
] | 953,459 | 953,463 | u884476319 | cpp |
p03160 | #pragma GCC optimize("O3")
#define _GLIBCXX_DEBUG
#include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <string_view>
#include <vector>
using namespace std;
/*----------macros----------*/
// output================
#define endl '\n'
#define fcout(a) cout << fixed << setprecision((int)(a))
// typedef===============
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<ll, ll> Pll;
// const number==========
constexpr ll INF9 = (ll)1e9 + 1;
constexpr ll INF18 = (ll)1e18 + 1;
constexpr ll MOD = 1'000'000'007;
constexpr ll MOD2 = 998'244'353;
constexpr ld PI = 3.141592653589793L;
// member================
#define pb push_back
#define eb emplace_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
// others================
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define rep(i, n) for (int i = 0; (i) < (n); ++(i))
#define reps(i, n) for (int i = 1; (i) <= (n); ++(i))
#define rrep(i, n) for (int i = n - 1; (i) >= 0; --(i))
#define CtoI(c) int((c)) - int('0')
#define ItoC(c) char((c) + '0')
// functions=============
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
// vector<int> dx = {1, 0, -1, 0}, dy = {0, 1, 0, -1};
// vector<int> dx2 = { 1,1,0,-1,-1,-1,0,1 }, dy2 = { 0,1,1,1,0,-1,-1,-1 };
/*--------additional--------*/
/*----------main------------*/
int main() {
/*----------fastio----------*/
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::ios::sync_with_stdio(false);
/*----------solve-----------*/
int n;
cin >> n;
vector<int> h(n);
rep(i, n) cin >> h[i];
int dp[n + 5];
dp[1] = abs(h[1] - h[0]);
for (int i = 2; i < n; ++i) {
dp[i] =
min(dp[i - 2] + abs(h[i] - h[i - 2]), dp[i - 1] + abs(h[i] - h[i - 1]));
}
cout << dp[n - 1] << endl;
return 0;
}
| #pragma GCC optimize("O3")
#define _GLIBCXX_DEBUG
#include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <string_view>
#include <vector>
using namespace std;
/*----------macros----------*/
// output================
#define endl '\n'
#define fcout(a) cout << fixed << setprecision((int)(a))
// typedef===============
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<ll, ll> Pll;
// const number==========
constexpr ll INF9 = (ll)1e9 + 1;
constexpr ll INF18 = (ll)1e18 + 1;
constexpr ll MOD = 1'000'000'007;
constexpr ll MOD2 = 998'244'353;
constexpr ld PI = 3.141592653589793L;
// member================
#define pb push_back
#define eb emplace_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
// others================
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define rep(i, n) for (int i = 0; (i) < (n); ++(i))
#define reps(i, n) for (int i = 1; (i) <= (n); ++(i))
#define rrep(i, n) for (int i = n - 1; (i) >= 0; --(i))
#define CtoI(c) int((c)) - int('0')
#define ItoC(c) char((c) + '0')
// functions=============
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
// vector<int> dx = {1, 0, -1, 0}, dy = {0, 1, 0, -1};
// vector<int> dx2 = { 1,1,0,-1,-1,-1,0,1 }, dy2 = { 0,1,1,1,0,-1,-1,-1 };
/*--------additional--------*/
/*----------main------------*/
int main() {
/*----------fastio----------*/
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::ios::sync_with_stdio(false);
/*----------solve-----------*/
int n;
cin >> n;
vector<int> h(n);
rep(i, n) cin >> h[i];
int dp[1000005];
dp[1] = abs(h[1] - h[0]);
for (int i = 2; i < n; ++i) {
dp[i] =
min(dp[i - 2] + abs(h[i] - h[i - 2]), dp[i - 1] + abs(h[i] - h[i - 1]));
}
cout << dp[n - 1] << endl;
return 0;
}
| [
"identifier.replace.remove",
"literal.replace.add",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 953,457 | 953,464 | u884476319 | cpp |
p03160 | #pragma GCC optimize("O3")
#define _GLIBCXX_DEBUG
#include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <string_view>
#include <vector>
using namespace std;
/*----------macros----------*/
// output================
#define endl '\n'
#define fcout(a) cout << fixed << setprecision((int)(a))
// typedef===============
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<ll, ll> Pll;
// const number==========
constexpr ll INF9 = (ll)1e9 + 1;
constexpr ll INF18 = (ll)1e18 + 1;
constexpr ll MOD = 1'000'000'007;
constexpr ll MOD2 = 998'244'353;
constexpr ld PI = 3.141592653589793L;
// member================
#define pb push_back
#define eb emplace_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
// others================
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define rep(i, n) for (int i = 0; (i) < (n); ++(i))
#define reps(i, n) for (int i = 1; (i) <= (n); ++(i))
#define rrep(i, n) for (int i = n - 1; (i) >= 0; --(i))
#define CtoI(c) int((c)) - int('0')
#define ItoC(c) char((c) + '0')
// functions=============
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
// vector<int> dx = {1, 0, -1, 0}, dy = {0, 1, 0, -1};
// vector<int> dx2 = { 1,1,0,-1,-1,-1,0,1 }, dy2 = { 0,1,1,1,0,-1,-1,-1 };
/*--------additional--------*/
/*----------main------------*/
int main() {
/*----------fastio----------*/
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::ios::sync_with_stdio(false);
/*----------solve-----------*/
int n;
cin >> n;
vector<int> h(n);
rep(i, n) cin >> h[i];
int dp[n];
dp[1] = abs(h[1] - h[0]);
for (int i = 2; i < n; ++i) {
dp[i] =
min(dp[i - 2] + abs(h[i] - h[i - 2]), dp[i - 1] + abs(h[i] - h[i - 1]));
}
cout << dp[n - 1] << endl;
return 0;
} | #pragma GCC optimize("O3")
#define _GLIBCXX_DEBUG
#include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <string_view>
#include <vector>
using namespace std;
/*----------macros----------*/
// output================
#define endl '\n'
#define fcout(a) cout << fixed << setprecision((int)(a))
// typedef===============
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<ll, ll> Pll;
// const number==========
constexpr ll INF9 = (ll)1e9 + 1;
constexpr ll INF18 = (ll)1e18 + 1;
constexpr ll MOD = 1'000'000'007;
constexpr ll MOD2 = 998'244'353;
constexpr ld PI = 3.141592653589793L;
// member================
#define pb push_back
#define eb emplace_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
// others================
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define rep(i, n) for (int i = 0; (i) < (n); ++(i))
#define reps(i, n) for (int i = 1; (i) <= (n); ++(i))
#define rrep(i, n) for (int i = n - 1; (i) >= 0; --(i))
#define CtoI(c) int((c)) - int('0')
#define ItoC(c) char((c) + '0')
// functions=============
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
// vector<int> dx = {1, 0, -1, 0}, dy = {0, 1, 0, -1};
// vector<int> dx2 = { 1,1,0,-1,-1,-1,0,1 }, dy2 = { 0,1,1,1,0,-1,-1,-1 };
/*--------additional--------*/
/*----------main------------*/
int main() {
/*----------fastio----------*/
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::ios::sync_with_stdio(false);
/*----------solve-----------*/
int n;
cin >> n;
vector<int> h(n);
rep(i, n) cin >> h[i];
int dp[1000005];
dp[1] = abs(h[1] - h[0]);
for (int i = 2; i < n; ++i) {
dp[i] =
min(dp[i - 2] + abs(h[i] - h[i - 2]), dp[i - 1] + abs(h[i] - h[i - 1]));
}
cout << dp[n - 1] << endl;
return 0;
}
| [
"identifier.replace.remove",
"literal.replace.add",
"variable_declaration.array_dimensions.change"
] | 953,459 | 953,464 | u884476319 | cpp |
p03160 | #pragma GCC optimize("O3")
#define _GLIBCXX_DEBUG
#include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <string_view>
#include <vector>
using namespace std;
/*----------macros----------*/
// output================
#define endl '\n'
#define fcout(a) cout << fixed << setprecision((int)(a))
// typedef===============
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<ll, ll> Pll;
// const number==========
constexpr ll INF9 = (ll)1e9 + 1;
constexpr ll INF18 = (ll)1e18 + 1;
constexpr ll MOD = 1'000'000'007;
constexpr ll MOD2 = 998'244'353;
constexpr ld PI = 3.141592653589793L;
// member================
#define pb push_back
#define eb emplace_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
// others================
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define rep(i, n) for (int i = 0; (i) < (n); ++(i))
#define reps(i, n) for (int i = 1; (i) <= (n); ++(i))
#define rrep(i, n) for (int i = n - 1; (i) >= 0; --(i))
#define CtoI(c) int((c)) - int('0')
#define ItoC(c) char((c) + '0')
// functions=============
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
// vector<int> dx = {1, 0, -1, 0}, dy = {0, 1, 0, -1};
// vector<int> dx2 = { 1,1,0,-1,-1,-1,0,1 }, dy2 = { 0,1,1,1,0,-1,-1,-1 };
/*--------additional--------*/
/*----------main------------*/
int main() {
/*----------fastio----------*/
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::ios::sync_with_stdio(false);
/*----------solve-----------*/
int n;
cin >> n;
vector<int> h(n);
rep(i, n) cin >> h[i];
int dp[n];
dp[1] = abs(h[1] - h[0]);
for (int i = 2; i < n; ++i) {
dp[i] =
min(dp[i - 2] + abs(h[i] - h[i - 2]), dp[i - 1] + abs(h[i] - h[i - 1]));
}
cout << dp[n - 1] << endl;
return 0;
} | #pragma GCC optimize("O3")
#define _GLIBCXX_DEBUG
#include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <string_view>
#include <vector>
using namespace std;
/*----------macros----------*/
// output================
#define endl '\n'
#define fcout(a) cout << fixed << setprecision((int)(a))
// typedef===============
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<ll, ll> Pll;
// const number==========
constexpr ll INF9 = (ll)1e9 + 1;
constexpr ll INF18 = (ll)1e18 + 1;
constexpr ll MOD = 1'000'000'007;
constexpr ll MOD2 = 998'244'353;
constexpr ld PI = 3.141592653589793L;
// member================
#define pb push_back
#define eb emplace_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
// others================
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define rep(i, n) for (int i = 0; (i) < (n); ++(i))
#define reps(i, n) for (int i = 1; (i) <= (n); ++(i))
#define rrep(i, n) for (int i = n - 1; (i) >= 0; --(i))
#define CtoI(c) int((c)) - int('0')
#define ItoC(c) char((c) + '0')
// functions=============
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
// vector<int> dx = {1, 0, -1, 0}, dy = {0, 1, 0, -1};
// vector<int> dx2 = { 1,1,0,-1,-1,-1,0,1 }, dy2 = { 0,1,1,1,0,-1,-1,-1 };
/*--------additional--------*/
/*----------main------------*/
int main() {
/*----------fastio----------*/
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::ios::sync_with_stdio(false);
/*----------solve-----------*/
int n;
cin >> n;
vector<int> h(n);
rep(i, n) cin >> h[i];
int dp[100'005];
dp[1] = abs(h[1] - h[0]);
for (int i = 2; i < n; ++i) {
dp[i] =
min(dp[i - 2] + abs(h[i] - h[i - 2]), dp[i - 1] + abs(h[i] - h[i - 1]));
}
cout << dp[n - 1] << endl;
return 0;
}
| [
"identifier.replace.remove",
"literal.replace.add",
"variable_declaration.array_dimensions.change"
] | 953,459 | 953,465 | u884476319 | cpp |
p03160 | #define _GLIBCXX_DEBUG
#include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define omajinai \
ios::sync_with_stdio(false); \
cin.tie(nullptr);
#pragma region typedef
typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> P;
#pragma endregion
#pragma region define
#define endl '\n'
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define rep(i, n) for (int i = 0; (i) < (n); (i)++)
#define pb push_back
#define pf push_front
#pragma endregion
#pragma region const
const ld PI = 3.141592653589793;
const ll INF18 = 1e18;
#pragma endregion
#pragma region function
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;
}
#pragma endregion
ll h[100010];
ll dp[100010];
int main() {
omajinai;
int n;
cin >> n;
rep(i, n) cin >> h[i];
rep(i, 100010) dp[i] = INF18;
dp[0] = 0;
for (int i = 1; i < n; i++) {
chmin(dp[i], dp[i - 1] + abs(h[i] + h[i - 1]));
if (i > 1) {
chmin(dp[i], dp[i - 2] + abs(dp[i] - dp[i - 2]));
}
}
cout << dp[n - 1];
return 0;
} | #define _GLIBCXX_DEBUG
#include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define omajinai \
ios::sync_with_stdio(false); \
cin.tie(nullptr);
#pragma region typedef
typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> P;
#pragma endregion
#pragma region define
#define endl '\n'
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define rep(i, n) for (int i = 0; (i) < (n); (i)++)
#define pb push_back
#define pf push_front
#pragma endregion
#pragma region const
const ld PI = 3.141592653589793;
const ll INF18 = 1e18;
#pragma endregion
#pragma region function
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;
}
#pragma endregion
ll h[100010];
ll dp[100010];
int main() {
omajinai;
int n;
cin >> n;
rep(i, n) cin >> h[i];
rep(i, 100010) dp[i] = INF18;
dp[0] = 0;
for (int i = 1; i < n; i++) {
chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
if (i > 1) {
chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
}
cout << dp[n - 1];
return 0;
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"call.arguments.change",
"expression.operation.binary.change",
"identifier.change"
] | 953,468 | 953,467 | u884476319 | cpp |
p03160 | #define _GLIBCXX_DEBUG
#include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define omajinai \
ios::sync_with_stdio(false); \
cin.tie(nullptr);
#pragma region typedef
typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> P;
#pragma endregion
#pragma region define
#define endl '\n'
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define rep(i, n) for (int i = 0; (i) < (n); (i)++)
#define pb push_back
#define pf push_front
#pragma endregion
#pragma region const
const ld PI = 3.141592653589793;
const ll INF18 = 1e18;
#pragma endregion
#pragma region function
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;
}
#pragma endregion
ll h[100010];
ll dp[100010];
int main() {
omajinai;
int n;
cin >> n;
rep(i, n) cin >> h[i];
rep(i, 100010) dp[i] = INF18;
dp[0] = 0;
for (int i = 1; i <= n; i++) {
chmin(dp[i], dp[i - 1] + abs(h[i] + h[i - 1]));
if (i > 1) {
chmin(dp[i], dp[i - 2] + abs(dp[i] - dp[i - 2]));
}
}
cout << dp[n - 1];
return 0;
} | #define _GLIBCXX_DEBUG
#include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define omajinai \
ios::sync_with_stdio(false); \
cin.tie(nullptr);
#pragma region typedef
typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> P;
#pragma endregion
#pragma region define
#define endl '\n'
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define rep(i, n) for (int i = 0; (i) < (n); (i)++)
#define pb push_back
#define pf push_front
#pragma endregion
#pragma region const
const ld PI = 3.141592653589793;
const ll INF18 = 1e18;
#pragma endregion
#pragma region function
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;
}
#pragma endregion
ll h[100010];
ll dp[100010];
int main() {
omajinai;
int n;
cin >> n;
rep(i, n) cin >> h[i];
rep(i, 100010) dp[i] = INF18;
dp[0] = 0;
for (int i = 1; i < n; i++) {
chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
if (i > 1) {
chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
}
cout << dp[n - 1];
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"misc.opposites",
"expression.operator.arithmetic.change",
"call.arguments.change",
"identifier.change"
] | 953,469 | 953,467 | u884476319 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
#define PB push_back
#define MP make_pair
#define endl '\n'
#define all(a) (a).begin(), (a).end()
#define optimize() \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
int n, k;
int arr[100005];
int dp[100005];
int f(int indx) {
if (indx >= n - 1)
return 0;
if (dp[indx] != -1)
return dp[indx];
int x = INT_MAX;
for (int i = 1; i <= 2; i++) {
if (indx + i <= n - 1)
x = min(x, abs(arr[indx] - arr[indx + i]) + f(indx + i));
}
return dp[indx] = x;
}
int main() {
optimize();
cin >> n >> k;
for (int i = 0; i < n; i++)
cin >> arr[i];
memset(dp, -1, sizeof(dp));
cout << f(0) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
#define PB push_back
#define MP make_pair
#define endl '\n'
#define all(a) (a).begin(), (a).end()
#define optimize() \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
int n, k;
int arr[100005];
int dp[100005];
int f(int indx) {
if (indx >= n - 1)
return 0;
if (dp[indx] != -1)
return dp[indx];
int x = INT_MAX;
for (int i = 1; i <= 2; i++) {
if (indx + i <= n - 1)
x = min(x, abs(arr[indx] - arr[indx + i]) + f(indx + i));
}
return dp[indx] = x;
}
int main() {
optimize();
cin >> n;
for (int i = 0; i < n; i++)
cin >> arr[i];
memset(dp, -1, sizeof(dp));
cout << f(0) << endl;
return 0;
}
| [
"expression.operation.binary.remove"
] | 953,470 | 953,471 | u963996446 | cpp |
p03160 | #include <bits/stdc++.h>
#define REP(x, y, z) for (int x = y; x <= z; x++)
#define MSET(x, y) memset(x, y, sizeof(x))
#define M 100005
using namespace std;
int n, h[M], dp[M];
int main() {
scanf("%d", &n);
REP(i, 1, n) scanf("%d", &h[i]);
dp[1] = 0;
REP(i, 2, n) {
dp[i] = dp[i - 1] + abs(h[i] - h[i - 1]);
dp[i] = min(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
printf("%d\n", dp[n]);
return 0;
}
| #include <bits/stdc++.h>
#define REP(x, y, z) for (int x = y; x <= z; x++)
#define MSET(x, y) memset(x, y, sizeof(x))
#define M 100005
using namespace std;
int n, h[M], dp[M];
int main() {
scanf("%d", &n);
REP(i, 1, n) scanf("%d", &h[i]);
dp[1] = 0;
REP(i, 2, n) {
dp[i] = dp[i - 1] + abs(h[i] - h[i - 1]);
if (i > 2)
dp[i] = min(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
printf("%d\n", dp[n]);
return 0;
}
| [
"control_flow.branch.if.add"
] | 953,472 | 953,473 | u863370423 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 100009;
ll cost[N], h[N];
int main() {
ll n, i, a, b;
scanf("%lld", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &h[i]);
}
cost[n - 1] = fabs(h[i - 1] - h[i]);
for (i = n - 2; i >= 1; i--) {
a = fabs(h[i] - h[i + 1]) + cost[i + 1];
b = fabs(h[i] - h[i + 2]) + cost[i + 2];
cost[i] = min(a, b);
}
printf("%lld\n", cost[1]);
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 100009;
ll cost[N], h[N];
int main() {
ll n, i, a, b;
scanf("%lld", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &h[i]);
}
cost[n - 1] = fabs(h[n - 1] - h[n]);
for (i = n - 2; i >= 1; i--) {
a = fabs(h[i] - h[i + 1]) + cost[i + 1];
b = fabs(h[i] - h[i + 2]) + cost[i + 2];
cost[i] = min(a, b);
}
printf("%lld\n", cost[1]);
} | [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 953,474 | 953,475 | u863370423 | cpp |
p03160 | #include <bits/stdc++.h>
// freopen("transmitters.in","r",stdin);
// cout<<fixed<<setprecision(6)<<n<<endl;
// transform(s.begin(), s.end(), s.begin(), ::tolower);
// double PI=3.14159265359,c=0;
#define all(v) v.begin(), v.end()
#define endl '\n'
#define ll long long
//#define f(n) for(int i=;i<n;i++)
double PI = acos(-1);
using namespace std;
void fast() {
std::ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
ll arr[100000];
int main() {
fast();
ll n, t, x, mn = 0;
cin >> n;
vector<ll> v(n, 1e12);
for (int i = 0; i < n; i++)
cin >> arr[i];
for (int i = 0; i < n; i++) {
x = v[i];
if (i + 1 < n) {
if (i == 0)
x = 0;
mn = x + abs(arr[i] - arr[i + 1]);
v[i + 1] = min(v[i + 1], mn);
}
if (i + 2 < n) {
if (i == 0)
x = 0;
mn = x + abs(arr[i] - arr[i + 2]);
v[i + 2] = min(v[i + 2], mn);
}
// cout<<v[i]<<" ";
}
cout << v[v.size() - 2] << endl;
return 0;
}
| #include <bits/stdc++.h>
// freopen("transmitters.in","r",stdin);
// cout<<fixed<<setprecision(6)<<n<<endl;
// transform(s.begin(), s.end(), s.begin(), ::tolower);
// double PI=3.14159265359,c=0;
#define all(v) v.begin(), v.end()
#define endl '\n'
#define ll long long
//#define f(n) for(int i=;i<n;i++)
double PI = acos(-1);
using namespace std;
void fast() {
std::ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
ll arr[100000];
int main() {
fast();
ll n, t, x, mn = 0;
cin >> n;
vector<ll> v(n, 1e12);
for (int i = 0; i < n; i++)
cin >> arr[i];
for (int i = 0; i < n; i++) {
x = v[i];
if (i + 1 < n) {
if (i == 0)
x = 0;
mn = x + abs(arr[i] - arr[i + 1]);
v[i + 1] = min(v[i + 1], mn);
}
if (i + 2 < n) {
if (i == 0)
x = 0;
mn = x + abs(arr[i] - arr[i + 2]);
v[i + 2] = min(v[i + 2], mn);
}
// cout<<v[i]<<" ";
}
cout << v[v.size() - 1] << endl;
return 0;
}
| [
"literal.number.change",
"variable_access.subscript.index.change",
"io.output.change"
] | 953,480 | 953,481 | u863370423 | cpp |
p03160 | #include <bits/stdc++.h>
#define MAX 100005
#define pb push_back
#define mp make_pair
#define pii pair<long long, long long>
#define read(a) scanf("%d", &a)
#define p1(a) cout << "Check " << a << endl;
#define p2(a, b) cout << "Check " << a << ' ' << b << endl;
#define p3(a, b, c) cout << "Check " << a << ' ' << b << ' ' << c << endl;
#define fo(i, n) for (i = 0; i < n; i++)
#define ll long long
#define clr(a) memset(a, 0, sizeof(a))
#define MOD 10000000000
#define INF 10000000000000;
using namespace std;
int main() {
int n;
cin >> n;
int ar[n + 10];
ll dp[MAX];
dp[0] = 0, dp[1] = 0, ar[0] = 0;
for (int i = 1; i <= n; i++)
scanf("%d", &ar[i]);
for (int i = 2; i <= n; i++) {
ll p = dp[i - 1] + abs(ar[i] - ar[i - 1]);
ll q = dp[i - 2] + abs(ar[i] - ar[i - 2]);
dp[i] = min(p, q);
}
cout << dp[n] << endl;
return 0;
}
| #include <bits/stdc++.h>
#define MAX 100005
#define pb push_back
#define mp make_pair
#define pii pair<long long, long long>
#define read(a) scanf("%d", &a)
#define p1(a) cout << "Check " << a << endl;
#define p2(a, b) cout << "Check " << a << ' ' << b << endl;
#define p3(a, b, c) cout << "Check " << a << ' ' << b << ' ' << c << endl;
#define fo(i, n) for (i = 0; i < n; i++)
#define ll long long
#define clr(a) memset(a, 0, sizeof(a))
#define MOD 10000000000
#define INF 10000000000000;
using namespace std;
int main() {
int n;
cin >> n;
int ar[n + 10];
ll dp[MAX];
dp[0] = 10000000000, dp[1] = 0, ar[0] = 10000000;
for (int i = 1; i <= n; i++)
scanf("%d", &ar[i]);
for (int i = 2; i <= n; i++) {
ll p = dp[i - 1] + abs(ar[i] - ar[i - 1]);
ll q = dp[i - 2] + abs(ar[i] - ar[i - 2]);
dp[i] = min(p, q);
// p3(dp[i],p,q);
}
cout << dp[n] << endl;
return 0;
}
| [
"literal.number.change",
"assignment.value.change"
] | 953,482 | 953,483 | u863370423 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> frog(n + 1, 0);
for (int i = 1; i <= n; i++) {
cin >> frog[i];
}
vector<int> dp(n + 5, 0);
dp[1] = abs(frog[1] - frog[0]);
for (int i = 3; i <= n; i++) {
dp[i] = min(dp[i - 1] + abs(frog[i - 1] - frog[i]),
dp[i - 2] + abs(frog[i] - frog[i - 2]));
}
cout << dp[n] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> frog(n + 1, 0);
for (int i = 1; i <= n; i++) {
cin >> frog[i];
}
vector<int> dp(n + 5, 0);
dp[2] = abs(frog[2] - frog[1]);
for (int i = 3; i <= n; i++) {
dp[i] = min(dp[i - 1] + abs(frog[i - 1] - frog[i]),
dp[i - 2] + abs(frog[i] - frog[i - 2]));
}
cout << dp[n] << endl;
return 0;
}
| [
"literal.number.change",
"assignment.variable.change",
"variable_access.subscript.index.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 953,484 | 953,485 | u863370423 | cpp |
p03160 | #include <bits/stdc++.h>
#include <unordered_map>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
using P = pair<ll, ll>;
using V = vector<ll>;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rep1(i, n) for (ll i = 1; i <= (ll)(n); i++)
#define rep2(i, m, n) for (ll i = m; i < (ll)(n); i++)
#define rep3(i, m, n) for (ll i = m; i <= (ll)(n); i++)
#define rrep(i, n, m) for (ll i = n; i >= (ll)(m); i--)
#define ALL(obj) (obj).begin(), (obj).end()
#define RALL(obj) (obj).rbegin(), (obj).rend()
#define MOD 1000000007
#define INF 1000000000
#define LLINF 1000000000000000000
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;
}
// auto mod int
// https://youtu.be/L8grWxBlIZ4?t=9858
// https://youtu.be/ERZuLAxZffQ?t=4807 : optimize
// https://youtu.be/8uowVvQ_-Mo?t=1329 : division
const ll mod = MOD;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
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;
}
};
ll dp[100005];
void solve_abc_d() {
ll n;
ll l_ans = 0;
cin >> n;
V h(n + 1);
rep(i, n) cin >> h[i + 1];
rep1(i, n) dp[i] = INF;
dp[1] = 0;
rep1(i, n) {
if (i == 0)
continue;
else if (i == 1) {
chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
} else {
chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
}
cout << dp[n] << "\n";
return;
}
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed;
cout << setprecision(15);
solve_abc_d();
return 0;
}
| #include <bits/stdc++.h>
#include <unordered_map>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
using P = pair<ll, ll>;
using V = vector<ll>;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rep1(i, n) for (ll i = 1; i <= (ll)(n); i++)
#define rep2(i, m, n) for (ll i = m; i < (ll)(n); i++)
#define rep3(i, m, n) for (ll i = m; i <= (ll)(n); i++)
#define rrep(i, n, m) for (ll i = n; i >= (ll)(m); i--)
#define ALL(obj) (obj).begin(), (obj).end()
#define RALL(obj) (obj).rbegin(), (obj).rend()
#define MOD 1000000007
#define INF 1000000000
#define LLINF 1000000000000000000
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;
}
// auto mod int
// https://youtu.be/L8grWxBlIZ4?t=9858
// https://youtu.be/ERZuLAxZffQ?t=4807 : optimize
// https://youtu.be/8uowVvQ_-Mo?t=1329 : division
const ll mod = MOD;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
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;
}
};
ll dp[100005];
void solve_abc_d() {
ll n;
ll l_ans = 0;
cin >> n;
V h(n + 1);
rep(i, n) cin >> h[i + 1];
rep1(i, n) dp[i] = INF;
dp[1] = 0;
rep1(i, n) {
if (i == 1)
continue;
else if (i == 2) {
chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
} else {
chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
}
cout << dp[n] << "\n";
return;
}
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed;
cout << setprecision(15);
solve_abc_d();
return 0;
}
| [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 953,486 | 953,487 | u145179061 | cpp |
p03160 | #include <cmath>
#include <iostream>
int n;
long long int dp[100001];
int h[100001];
int main() {
std::cin >> n;
for (int i = 0; i < n; i++) {
dp[i] = 100000;
std::cin >> h[i];
}
dp[0] = 0;
for (int i = 0; i < n - 1; i++) {
if (dp[i] + abs(h[i + 1] - h[i]) < dp[i + 1]) {
dp[i + 1] = dp[i] + abs(h[i + 1] - h[i]);
}
if (dp[i] + abs(h[i + 2] - h[i]) < dp[i + 2]) {
dp[i + 2] = dp[i] + abs(h[i + 2] - h[i]);
}
}
std::cout << dp[n - 1] << std::endl;
}
| #include <cmath>
#include <iostream>
int n;
int dp[100001];
int h[100001];
int main() {
std::cin >> n;
for (int i = 0; i < n; i++) {
dp[i] = 2000000000;
std::cin >> h[i];
}
dp[0] = 0;
for (int i = 0; i < n - 1; i++) {
if (dp[i] + abs(h[i + 1] - h[i]) < dp[i + 1]) {
dp[i + 1] = dp[i] + abs(h[i + 1] - h[i]);
}
if (dp[i] + abs(h[i + 2] - h[i]) < dp[i + 2]) {
dp[i + 2] = dp[i] + abs(h[i + 2] - h[i]);
}
}
std::cout << dp[n - 1] << std::endl;
}
| [
"literal.number.change",
"assignment.value.change"
] | 953,488 | 953,489 | u956593558 | cpp |
p03160 | #include <cmath>
#include <iostream>
int n;
int dp[100001];
int h[100001];
int main() {
std::cin >> n;
for (int i = 0; i < n; i++) {
dp[i] = 100000;
std::cin >> h[i];
}
dp[0] = 0;
for (int i = 0; i < n - 1; i++) {
if (dp[i] + abs(h[i + 1] - h[i]) < dp[i + 1]) {
dp[i + 1] = dp[i] + abs(h[i + 1] - h[i]);
}
if (dp[i] + abs(h[i + 2] - h[i]) < dp[i + 2]) {
dp[i + 2] = dp[i] + abs(h[i + 2] - h[i]);
}
}
std::cout << dp[n - 1] << std::endl;
}
| #include <cmath>
#include <iostream>
int n;
int dp[100001];
int h[100001];
int main() {
std::cin >> n;
for (int i = 0; i < n; i++) {
dp[i] = 2000000000;
std::cin >> h[i];
}
dp[0] = 0;
for (int i = 0; i < n - 1; i++) {
if (dp[i] + abs(h[i + 1] - h[i]) < dp[i + 1]) {
dp[i + 1] = dp[i] + abs(h[i + 1] - h[i]);
}
if (dp[i] + abs(h[i + 2] - h[i]) < dp[i + 2]) {
dp[i + 2] = dp[i] + abs(h[i + 2] - h[i]);
}
}
std::cout << dp[n - 1] << std::endl;
}
| [
"literal.number.change",
"assignment.value.change"
] | 953,490 | 953,489 | u956593558 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int h[N];
for (int i = 0; i < N; i++) {
cin >> h[i];
}
int dp[N];
dp[0] = 0;
dp[1] = abs(h[1] - h[0]);
dp[2] = abs(h[2] - h[0]);
for (int i = 0; i < N - 2; i++) {
dp[i + 2] =
min(dp[i] + abs(h[i + 2] - h[i]), dp[i + 1] + abs(h[i + 1] - h[i]));
}
cout << dp[N - 1] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int h[N];
for (int i = 0; i < N; i++) {
cin >> h[i];
}
int dp[N];
dp[0] = 0;
dp[1] = abs(h[1] - h[0]);
dp[2] = abs(h[2] - h[0]);
for (int i = 0; i < N - 2; i++) {
dp[i + 2] =
min(dp[i] + abs(h[i + 2] - h[i]), dp[i + 1] + abs(h[i + 2] - h[i + 1]));
}
cout << dp[N - 1] << endl;
return 0;
} | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change",
"assignment.change"
] | 953,494 | 953,495 | u083494782 | cpp |
p03160 | #include <algorithm>
#include <bits/stdc++.h>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
const long long int INF = 1e+5;
int main() {
long long N;
cin >> N;
vector<long long> h(N);
for (long long i = 0; i < N; i++)
cin >> h[i];
vector<long long> dp(N, INF);
dp[0] = 0;
for (long long i = 0; i < N; i++) {
for (long long j = i + 1; j <= i + 2; j++) {
if (j < N) {
dp[j] = min(dp[j], dp[i] + abs(h[i] - h[j]));
}
}
}
cout << dp[N - 1];
return 0;
}
| #include <algorithm>
#include <bits/stdc++.h>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
const long long int INF = 1e9 + 5;
int main() {
long long N;
cin >> N;
vector<long long> h(N);
for (long long i = 0; i < N; i++)
cin >> h[i];
vector<long long> dp(N, INF);
dp[0] = 0;
for (long long i = 0; i < N; i++) {
for (long long j = i + 1; j <= i + 2; j++) {
if (j < N) {
dp[j] = min(dp[j], dp[i] + abs(h[i] - h[j]));
}
}
}
cout << dp[N - 1];
return 0;
}
| [
"literal.number.change"
] | 953,498 | 953,499 | u395652671 | cpp |
p03160 | /*
HELLO WORLD
-----------
SHUBHAM
-----------
:) CODING
*/
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define ff first
#define ss second
#define pb push_back
#define int long long
#define mp make_pair
#define pii pair<int, int>
#define vi vector<int>
#define mii map<int, int>
#define umii unordered_map<int, int>
#define pqb priority_queue<int>
#define pqs priority_queue<int, vi, greater<int>>
#define setbits(x) __builtin_popcountll(x)
#define zerobits(x) __builtin_ctzll(x)
#define mod 1000000007
#define inf 1e18
#define ps(x, y) fixed << setprecision(y) << x
#define mk(arr, n, type) type *arr = new type[n]
#define test(t) \
int t; \
cin >> t; \
while (t--)
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep1(i, n) for (int i = 1; i <= n; i++)
#define fio \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define SIZE 1000001
#define all(x) (x).begin(), (x).end()
#define sclk() auto start_time = Clock::now()
#define eclk() \
auto end_time = Clock::now(); \
cout << "\nTime Taken : " \
<< chrono::duration_cast<chrono::milliseconds>(end_time - start_time) \
.count() \
<< " ms"
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;
typedef std::chrono::high_resolution_clock Clock;
int powmod(int a, int b) {
int res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1)
res = res * a % mod;
a = a * a % mod;
}
return res;
}
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
void f_io() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif // ONLINE_JUDGE
}
int dp[100000];
int arr[100000];
int n;
int solve() {
dp[0] = 0;
dp[1] = arr[1] - arr[0];
for (int i = 2; i < n; i++)
dp[i] = min(dp[i - 1] + abs(arr[i] - arr[i - 1]),
dp[i - 2] + abs(arr[i] - arr[i - 2]));
return dp[n - 1];
}
int32_t main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
cout << solve();
return 0;
}
| /*
HELLO WORLD
-----------
SHUBHAM
-----------
:) CODING
*/
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define ff first
#define ss second
#define pb push_back
#define int long long
#define mp make_pair
#define pii pair<int, int>
#define vi vector<int>
#define mii map<int, int>
#define umii unordered_map<int, int>
#define pqb priority_queue<int>
#define pqs priority_queue<int, vi, greater<int>>
#define setbits(x) __builtin_popcountll(x)
#define zerobits(x) __builtin_ctzll(x)
#define mod 1000000007
#define inf 1e18
#define ps(x, y) fixed << setprecision(y) << x
#define mk(arr, n, type) type *arr = new type[n]
#define test(t) \
int t; \
cin >> t; \
while (t--)
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep1(i, n) for (int i = 1; i <= n; i++)
#define fio \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define SIZE 1000001
#define all(x) (x).begin(), (x).end()
#define sclk() auto start_time = Clock::now()
#define eclk() \
auto end_time = Clock::now(); \
cout << "\nTime Taken : " \
<< chrono::duration_cast<chrono::milliseconds>(end_time - start_time) \
.count() \
<< " ms"
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;
typedef std::chrono::high_resolution_clock Clock;
int powmod(int a, int b) {
int res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1)
res = res * a % mod;
a = a * a % mod;
}
return res;
}
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
void f_io() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif // ONLINE_JUDGE
}
int dp[100000];
int arr[100000];
int n;
int solve() {
dp[0] = 0;
dp[1] = abs(arr[1] - arr[0]);
for (int i = 2; i < n; i++)
dp[i] = min(dp[i - 1] + abs(arr[i] - arr[i - 1]),
dp[i - 2] + abs(arr[i] - arr[i - 2]));
return dp[n - 1];
}
int32_t main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
cout << solve();
return 0;
}
| [
"call.add",
"call.arguments.change"
] | 953,504 | 953,505 | u924233799 | cpp |
p03160 | /******************************************************************************
Online C++ Compiler.
Code, Compile, Run and Debug C++ program online.
Write your code in this editor and press "Run" button to compile and execute it.
*******************************************************************************/
#include <bits/stdc++.h>
#include <iostream>
using namespace std;
long long int count(int n, vector<long long int> &a) {
vector<long long int> dp(n + 1, 0);
dp[2] = abs(a[1] - a[0]);
for (long long int i = 3; i < n + 1; i++) {
dp[i] =
min(dp[i - 1] + abs(a[i] - a[i - 1]), dp[i - 2] + abs(a[i] - a[i - 2]));
}
return dp[n];
}
int main() {
long long int n;
cin >> n;
vector<long long int> a(n + 1, 0);
for (long long int i = 1; i < n + 1; i++) {
long long int x;
cin >> x;
a[i] = x;
}
cout << count(n, a);
return 0;
}
| /******************************************************************************
Online C++ Compiler.
Code, Compile, Run and Debug C++ program online.
Write your code in this editor and press "Run" button to compile and execute it.
*******************************************************************************/
#include <bits/stdc++.h>
#include <iostream>
using namespace std;
long long int count(int n, vector<long long int> &a) {
vector<long long int> dp(n + 1, 0);
dp[2] = abs(a[1] - a[2]);
for (long long int i = 3; i < n + 1; i++) {
dp[i] =
min(dp[i - 1] + abs(a[i] - a[i - 1]), dp[i - 2] + abs(a[i] - a[i - 2]));
}
return dp[n];
}
int main() {
long long int n;
cin >> n;
vector<long long int> a(n + 1, 0);
for (long long int i = 1; i < n + 1; i++) {
long long int x;
cin >> x;
a[i] = x;
}
cout << count(n, a);
return 0;
}
| [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 953,517 | 953,518 | u045238638 | cpp |
p03160 | #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<int> h(n), dp(n);
for (int i = 0; i < n; i++) {
cin >> h[i];
}
dp[0] = 0;
dp[1] = h[1] - h[0];
for (int i = 2; i < n; i++) {
dp[i] =
min(dp[i - 2] + abs(h[i - 2] - h[i]), dp[i - 1] + abs(h[i - 1] - h[i]));
}
cout << dp[n - 1] << 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<int> h(n), dp(n);
for (int i = 0; i < n; i++) {
cin >> h[i];
}
dp[0] = 0;
dp[1] = abs(h[1] - h[0]);
for (int i = 2; i < n; i++) {
dp[i] =
min(dp[i - 2] + abs(h[i - 2] - h[i]), dp[i - 1] + abs(h[i - 1] - h[i]));
}
cout << dp[n - 1] << endl;
return 0;
} | [
"call.add",
"call.arguments.change"
] | 953,524 | 953,525 | u530350853 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int n, a[100001], dp[100001];
int main() {
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i];
dp[1] = 0;
dp[2] = abs(a[1] - a[2]);
for (int i = 3; i <= n; i++)
dp[i] =
min(dp[i - 1] + abs(a[i] - a[i - 1]), dp[i - 2] + abs(a[i] - a[i - 1]));
cout << dp[n];
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int n, a[100001], dp[100001];
int main() {
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i];
dp[1] = 0;
dp[2] = abs(a[1] - a[2]);
for (int i = 3; i <= n; i++)
dp[i] =
min(dp[i - 1] + abs(a[i] - a[i - 1]), dp[i - 2] + abs(a[i] - a[i - 2]));
cout << dp[n];
return 0;
} | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 953,528 | 953,529 | u422780284 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int n, a[100001], dp[100001];
int main() {
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i];
dp[1] = a[1];
dp[2] = abs(a[1] - a[2]);
for (int i = 3; i <= n; i++)
dp[i] =
min(dp[i - 1] + abs(a[i] - a[i - 1]), dp[i - 2] + abs(a[i] - a[i - 2]));
cout << dp[n];
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int n, a[100001], dp[100001];
int main() {
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i];
dp[1] = 0;
dp[2] = abs(a[1] - a[2]);
for (int i = 3; i <= n; i++)
dp[i] =
min(dp[i - 1] + abs(a[i] - a[i - 1]), dp[i - 2] + abs(a[i] - a[i - 2]));
cout << dp[n];
return 0;
} | [
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add"
] | 953,530 | 953,529 | u422780284 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int n, a[100001], dp[100001];
int main() {
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i];
dp[1] = a[1];
dp[2] = abs(a[1] - a[2]);
for (int i = 3; i <= n; i++)
dp[i] =
min(dp[i - 1] + abs(a[i] - a[i - 1]), dp[i - 2] + abs(a[i] - a[i - 1]));
cout << dp[n];
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int n, a[100001], dp[100001];
int main() {
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i];
dp[1] = 0;
dp[2] = abs(a[1] - a[2]);
for (int i = 3; i <= n; i++)
dp[i] =
min(dp[i - 1] + abs(a[i] - a[i - 1]), dp[i - 2] + abs(a[i] - a[i - 2]));
cout << dp[n];
return 0;
} | [
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add",
"literal.number.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 953,531 | 953,529 | u422780284 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
ll solve(int i, vector<ll> v, int n, vector<ll> &dp) {
if (i == n - 1)
return 0;
if (dp[i] != -1)
return dp[i];
ll cur = LONG_MAX;
if (i + 1 < n) {
cur = min(cur, abs(v[i] - v[i + 1]) + solve(i + 1, v, n, dp));
}
if (i + 2 < n) {
cur = min(cur, abs(v[i] - v[i + 2]) + solve(i + 2, v, n, dp));
}
dp[i] = cur;
return cur;
}
ll bottomUp(vector<ll> v) {
int n = v.size();
vector<ll> dp(n);
dp[n - 1] = 0;
for (int i = n - 2; i >= 0; i--) {
if (i == n - 2) {
dp[i] = abs(v[i] - v[i + 1]);
} else
dp[i] = min(abs(v[i] - v[i + 1]) + dp[i + 1],
abs(v[i] - v[i + 2] + dp[i + 2]));
}
return dp[0];
}
int main() {
int n;
cin >> n;
vector<ll> v(n);
for (int i = 0; i < n; i++)
cin >> v[i];
// vector<ll> dp(n,-1);
// cout<<solve(0,v,n,dp);
cout << bottomUp(v);
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long int
ll solve(int i, vector<ll> v, int n, vector<ll> &dp) {
if (i == n - 1)
return 0;
if (dp[i] != -1)
return dp[i];
ll cur = LONG_MAX;
if (i + 1 < n) {
cur = min(cur, abs(v[i] - v[i + 1]) + solve(i + 1, v, n, dp));
}
if (i + 2 < n) {
cur = min(cur, abs(v[i] - v[i + 2]) + solve(i + 2, v, n, dp));
}
dp[i] = cur;
return cur;
}
ll bottomUp(vector<ll> v) {
int n = v.size();
vector<ll> dp(n);
dp[n - 1] = 0;
for (int i = n - 2; i >= 0; i--) {
if (i == n - 2) {
dp[i] = abs(v[i] - v[i + 1]);
} else
dp[i] = min(abs(v[i] - v[i + 1]) + dp[i + 1],
abs(v[i] - v[i + 2]) + dp[i + 2]);
}
return dp[0];
}
int main() {
int n;
cin >> n;
vector<ll> v(n);
for (int i = 0; i < n; i++)
cin >> v[i];
// vector<ll> dp(n,-1);
// cout<<solve(0,v,n,dp);
cout << bottomUp(v);
}
| [
"call.arguments.change"
] | 953,539 | 953,540 | u294694938 | cpp |
p03160 | /*
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
| |
| author : thanos1399 Language : C ++ |
| college : MSIT |
| _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
*/
#include <algorithm>
#include <bits/stdc++.h>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define TEST \
int t; \
cin >> t; \
while (t--)
#define line cout << endl;
#define loop(i, a, b) for (long long int i = a; i < b; i++)
#define loopIn(i, a, b) for (long long int i = a; i <= b; i++)
#define MAX_SIZE 1000000
#define ff first
#define ss second
#define pb push_back
#define ll long long int
#define mp make_pair
#define vt vector<tup>
#define vtt vector<vt>
#define pii pair<int, int>
#define vi vector<int>
#define mii map<int, int>
#define pqb priority_queue<int>
#define pqs priority_queue<int, vi, greater<int>>
#define setbits(x) __builtin_popcountll(x)
#define zrobits(x) __builtin_ctzll(x)
#define mod 1000000007
#define inf 1e18
#define ps(x, y) fixed << setprecision(y) << x
#define mk(arr, n, type) type *arr = new type[n];
void Sieve(int *prime, int n) {
for (int i = 0; i < n; i++) {
prime[i] = 0;
}
for (int i = 2; i < n; i++) {
prime[i] = 1;
}
for (int i = 4; i < n; i += 2) {
prime[i] = 0;
}
for (int i = 3; i < n; i++) {
if (prime[i] == 1) {
for (int j = i * i; j < n; j += i) {
prime[j] = 0;
}
}
}
return;
}
void input() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("/home/yash/Desktop/CPP/input.txt", "r", stdin);
freopen("/home/yash/Desktop/CPP/output.txt", "w", stdout);
#endif
}
ll inp;
int parent[101];
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second < b.second);
}
/*int find(int a)
{
while(parent[a] > 0)
a = parent[a];
return a;
} */
void Union(int a, int b) {
parent[a] += parent[b]; // adding size of set b to set a
parent[b] = a; // making a , parent of new set
}
int find(int node) {
if (parent[node] < 0)
return node;
parent[node] = find(parent[node]);
return parent[node];
}
int main() {
input();
int n;
cin >> n;
vi V;
loop(i, 0, n) {
cin >> inp;
V.pb(inp);
}
int dp[n];
dp[0] = 0;
dp[1] = abs(V[0] - V[1]);
loop(i, 2, n) {
int ans1 = dp[i - 1] + abs(V[i] - V[i - 1]);
int ans2 = dp[i - 2] + abs(V[i] - V[i - 2]);
dp[i] = min(ans1, ans2);
}
cout << dp[n - 1] << endl;
return 0;
} | /*
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
| |
| author : thanos1399 Language : C ++ |
| college : MSIT |
| _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
*/
#include <algorithm>
#include <bits/stdc++.h>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define TEST \
int t; \
cin >> t; \
while (t--)
#define line cout << endl;
#define loop(i, a, b) for (long long int i = a; i < b; i++)
#define loopIn(i, a, b) for (long long int i = a; i <= b; i++)
#define MAX_SIZE 1000000
#define ff first
#define ss second
#define pb push_back
#define ll long long int
#define mp make_pair
#define vt vector<tup>
#define vtt vector<vt>
#define pii pair<int, int>
#define vi vector<int>
#define mii map<int, int>
#define pqb priority_queue<int>
#define pqs priority_queue<int, vi, greater<int>>
#define setbits(x) __builtin_popcountll(x)
#define zrobits(x) __builtin_ctzll(x)
#define mod 1000000007
#define inf 1e18
#define ps(x, y) fixed << setprecision(y) << x
#define mk(arr, n, type) type *arr = new type[n];
void Sieve(int *prime, int n) {
for (int i = 0; i < n; i++) {
prime[i] = 0;
}
for (int i = 2; i < n; i++) {
prime[i] = 1;
}
for (int i = 4; i < n; i += 2) {
prime[i] = 0;
}
for (int i = 3; i < n; i++) {
if (prime[i] == 1) {
for (int j = i * i; j < n; j += i) {
prime[j] = 0;
}
}
}
return;
}
void input() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("/home/yash/Desktop/CPP/input.txt", "r", stdin);
freopen("/home/yash/Desktop/CPP/output.txt", "w", stdout);
#endif
}
ll inp;
int parent[101];
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second < b.second);
}
/*int find(int a)
{
while(parent[a] > 0)
a = parent[a];
return a;
} */
void Union(int a, int b) {
parent[a] += parent[b]; // adding size of set b to set a
parent[b] = a; // making a , parent of new set
}
int find(int node) {
if (parent[node] < 0)
return node;
parent[node] = find(parent[node]);
return parent[node];
}
int main() {
// input();
int n;
cin >> n;
vi V;
loop(i, 0, n) {
cin >> inp;
V.pb(inp);
}
int dp[n];
dp[0] = 0;
dp[1] = abs(V[0] - V[1]);
loop(i, 2, n) {
int ans1 = dp[i - 1] + abs(V[i] - V[i - 1]);
int ans2 = dp[i - 2] + abs(V[i] - V[i - 2]);
dp[i] = min(ans1, ans2);
}
cout << dp[n - 1] << endl;
return 0;
} | [
"call.remove"
] | 953,545 | 953,546 | u332867154 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n;
cin >> n;
ll h[n + 1];
ll dp[n + 1];
for (ll i = 1; i <= n; i++) {
cin >> h[i];
}
dp[0] = 0;
dp[1] = 0;
dp[2] = h[2] - h[1];
for (ll i = 3; i <= n; i++) {
dp[i] =
min(dp[i - 1] + abs(h[i] - h[i - 1]), dp[i - 2] + abs(h[i] - h[i - 2]));
}
cout << dp[n] << '\n';
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n;
cin >> n;
ll h[n + 1];
ll dp[n + 1];
for (ll i = 1; i <= n; i++) {
cin >> h[i];
}
dp[0] = 0;
dp[1] = 0;
dp[2] = abs(h[2] - h[1]);
for (ll i = 3; i <= n; i++) {
dp[i] =
min(dp[i - 1] + abs(h[i] - h[i - 1]), dp[i - 2] + abs(h[i] - h[i - 2]));
}
cout << dp[n] << '\n';
return 0;
} | [
"call.add",
"call.arguments.change"
] | 953,549 | 953,550 | u470829007 | cpp |
p03160 | #include <climits>
#include <cstring>
#include <iostream>
using namespace std;
int memoTable[100000];
int minCost(int index, int *stoneHeight, int nStones) {
if (index == nStones) {
return 0;
}
if (memoTable[index] != -1) {
return memoTable[index];
}
int op1 = (index + 1, stoneHeight, nStones) +
abs(stoneHeight[index] - stoneHeight[index + 1]);
int op2 = INT_MAX;
if (index + 2 < nStones) {
op2 = (index + 2, stoneHeight, nStones) +
abs(stoneHeight[index] - stoneHeight[index + 2]);
}
memoTable[index] = min(op1, op2);
return memoTable[index];
}
int main() {
int nStones;
cin >> nStones;
int stoneHeight[100000];
for (int i = 0; i < nStones; ++i) {
cin >> stoneHeight[i];
}
memset(memoTable, -1, sizeof(int) * 100000);
cout << minCost(0, stoneHeight, nStones);
return 0;
} | #include <climits>
#include <cstring>
#include <iostream>
using namespace std;
int memoTable[100000];
int minCost(int index, int *stoneHeight, int nStones) {
if (index == nStones - 1) {
return 0;
}
if (memoTable[index] != -1) {
return memoTable[index];
}
int op1 = minCost(index + 1, stoneHeight, nStones) +
abs(stoneHeight[index] - stoneHeight[index + 1]);
int op2 = INT_MAX;
if (index + 2 < nStones) {
op2 = minCost(index + 2, stoneHeight, nStones) +
abs(stoneHeight[index] - stoneHeight[index + 2]);
}
memoTable[index] = min(op1, op2);
return memoTable[index];
}
int main() {
int nStones;
cin >> nStones;
int stoneHeight[100000];
for (int i = 0; i < nStones; ++i) {
cin >> stoneHeight[i];
}
memset(memoTable, -1, sizeof(int) * 100000);
cout << minCost(0, stoneHeight, nStones);
return 0;
} | [
"control_flow.branch.if.condition.change",
"expression.operation.binary.add",
"call.add"
] | 953,556 | 953,557 | u508422627 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ll int n;
cin >> n;
ll int a[n];
for (ll int i = 0; i < n; i++)
cin >> a[i];
ll int dp[n] = {0};
dp[0] = 0;
dp[1] = abs(a[1] - a[0]);
if (n > 2)
dp[2] = min(abs(a[2] - a[0]), dp[1] + a[2] - a[1]);
for (int i = 3; i < n; i++) {
dp[i] =
min(dp[i - 1] + abs(a[i] - a[i - 1]), dp[i - 2] + abs(a[i] - a[i - 2]));
}
cout << dp[n - 1] << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ll int n;
cin >> n;
ll int a[n];
for (ll int i = 0; i < n; i++)
cin >> a[i];
ll int dp[n] = {0};
dp[0] = 0;
dp[1] = abs(a[1] - a[0]);
if (n > 2)
dp[2] = min(abs(a[2] - a[0]), dp[1] + abs(a[2] - a[1]));
for (int i = 3; i < n; i++) {
dp[i] =
min(dp[i - 1] + abs(a[i] - a[i - 1]), dp[i - 2] + abs(a[i] - a[i - 2]));
}
cout << dp[n - 1] << endl;
} | [
"call.add",
"call.arguments.change"
] | 953,562 | 953,563 | u322729493 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define frst first
#define sec second
#define fast cin.tie(0), ios_base ::sync_with_stdio(0)
#define db double
#define mod 1000000007
void online_judge() {
#ifndef ONLINE_JUDGE
freopen("Input.txt", "r", stdin);
freopen("Output.txt", "w", stdout);
#endif
}
ll lpp(string s) {
string rev = s;
reverse(rev.begin(), rev.end());
s = s + '#' + rev;
////cout << s << " ";
vector<ll> z(s.size(), 0);
ll l = 0, r = 0;
for (int i = 1; i < s.size(); ++i) {
if (i > r) {
l = r = i;
while (s[r] == s[r - l]) {
r++;
}
z[i] = (r - l);
r--;
} else {
if (z[i - l] + i <= r)
z[i] = z[i - l];
else {
l = i;
while (s[r] == s[r - l])
r++;
z[i] = (r - l);
r--;
}
}
}
ll ans = 0;
for (int i = 0; i < s.size(); ++i) {
if (z[i] + i == s.size()) {
ans = max(ans, z[i]);
}
}
return ans;
}
string binary(ll n) {
string s;
while (n) {
if ((n & 1))
s += '1';
else
s += '0';
n >>= 1;
}
reverse(s.begin(), s.end());
return s;
}
bool pos(vector<ll> &v, ll val, ll painters) {
ll cur = 0;
ll k = 1;
for (int i = 0; i < v.size(); ++i) {
if (v[i] > val)
return 0;
if (cur + v[i] <= val)
cur += v[i];
else {
k++;
cur = v[i];
}
}
cout << k << endl;
return (k <= painters);
}
class node {
node *next;
node *random;
ll val;
node(ll x) {
next = random = NULL;
val = x;
}
};
ll dp[101][101][1001];
ll cal(ll a[], ll cur, ll n, ll sum, ll c, ll tot) {
if (n == 0) {
/// cout << cur << " " << sum << " " << c << endl;
if (cur == tot / 2)
return abs((sum - c) - c);
return 1e8;
}
if (dp[n][cur][c] != 1e8) {
/// cout << dp[n][cur][c] << " ";
return dp[n][cur][c];
}
/// cout << dp[n][cur][c] << " ";
dp[n][cur][c] = cal(a, cur, n - 1, sum, c, tot);
dp[n][cur][c] =
min(dp[n][cur][c], cal(a, cur + 1, n - 1, sum, c + a[n - 1], tot));
// cout << ans << endl;
return dp[n][cur][c];
}
void go() {
ll n;
cin >> n;
ll a[n];
for (int i = 0; i < n; ++i)
cin >> a[i];
ll dp[3];
// memset(dp , 0, sizeof dp);
for (int i = 0; i < 3; ++i)
dp[i] = 1e8;
dp[0] = 0;
for (int i = 1; i < n; ++i) {
dp[i % 3] =
min(dp[(i - 1 + 3) % 3] + abs(a[i] - a[i - 1]),
(i >= 2) ? dp[(i - 2 + 3) % 3] + abs(a[i - 2] - a[i]) : (ll)1e8);
}
cout << dp[(n - 1) % 3];
}
int main() {
fast;
online_judge();
go();
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define frst first
#define sec second
#define fast cin.tie(0), ios_base ::sync_with_stdio(0)
#define db double
#define mod 1000000007
void online_judge() {
#ifndef ONLINE_JUDGE
freopen("Input.txt", "r", stdin);
freopen("Output.txt", "w", stdout);
#endif
}
ll lpp(string s) {
string rev = s;
reverse(rev.begin(), rev.end());
s = s + '#' + rev;
////cout << s << " ";
vector<ll> z(s.size(), 0);
ll l = 0, r = 0;
for (int i = 1; i < s.size(); ++i) {
if (i > r) {
l = r = i;
while (s[r] == s[r - l]) {
r++;
}
z[i] = (r - l);
r--;
} else {
if (z[i - l] + i <= r)
z[i] = z[i - l];
else {
l = i;
while (s[r] == s[r - l])
r++;
z[i] = (r - l);
r--;
}
}
}
ll ans = 0;
for (int i = 0; i < s.size(); ++i) {
if (z[i] + i == s.size()) {
ans = max(ans, z[i]);
}
}
return ans;
}
string binary(ll n) {
string s;
while (n) {
if ((n & 1))
s += '1';
else
s += '0';
n >>= 1;
}
reverse(s.begin(), s.end());
return s;
}
bool pos(vector<ll> &v, ll val, ll painters) {
ll cur = 0;
ll k = 1;
for (int i = 0; i < v.size(); ++i) {
if (v[i] > val)
return 0;
if (cur + v[i] <= val)
cur += v[i];
else {
k++;
cur = v[i];
}
}
cout << k << endl;
return (k <= painters);
}
class node {
node *next;
node *random;
ll val;
node(ll x) {
next = random = NULL;
val = x;
}
};
ll dp[101][101][1001];
ll cal(ll a[], ll cur, ll n, ll sum, ll c, ll tot) {
if (n == 0) {
/// cout << cur << " " << sum << " " << c << endl;
if (cur == tot / 2)
return abs((sum - c) - c);
return 1e8;
}
if (dp[n][cur][c] != 1e8) {
/// cout << dp[n][cur][c] << " ";
return dp[n][cur][c];
}
/// cout << dp[n][cur][c] << " ";
dp[n][cur][c] = cal(a, cur, n - 1, sum, c, tot);
dp[n][cur][c] =
min(dp[n][cur][c], cal(a, cur + 1, n - 1, sum, c + a[n - 1], tot));
// cout << ans << endl;
return dp[n][cur][c];
}
void go() {
ll n;
cin >> n;
ll a[n];
for (int i = 0; i < n; ++i)
cin >> a[i];
ll dp[3];
// memset(dp , 0, sizeof dp);
for (int i = 0; i < 3; ++i)
dp[i] = 1e8;
dp[0] = 0;
for (int i = 1; i < n; ++i) {
dp[i % 3] =
min(dp[(i - 1 + 3) % 3] + abs(a[i] - a[i - 1]),
(i >= 2) ? dp[(i - 2 + 3) % 3] + abs(a[i - 2] - a[i]) : (ll)1e8);
}
cout << dp[(n - 1) % 3];
}
int main() {
fast;
// online_judge();
go();
} | [
"call.remove"
] | 953,564 | 953,565 | u723601567 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define frst first
#define sec second
#define fast cin.tie(0), ios_base ::sync_with_stdio(0)
#define db double
#define mod 1000000007
void online_judge() {
#ifndef ONLINE_JUDGE
freopen("Input.txt", "r", stdin);
freopen("Output.txt", "w", stdout);
#endif
}
ll lpp(string s) {
string rev = s;
reverse(rev.begin(), rev.end());
s = s + '#' + rev;
////cout << s << " ";
vector<ll> z(s.size(), 0);
ll l = 0, r = 0;
for (int i = 1; i < s.size(); ++i) {
if (i > r) {
l = r = i;
while (s[r] == s[r - l]) {
r++;
}
z[i] = (r - l);
r--;
} else {
if (z[i - l] + i <= r)
z[i] = z[i - l];
else {
l = i;
while (s[r] == s[r - l])
r++;
z[i] = (r - l);
r--;
}
}
}
ll ans = 0;
for (int i = 0; i < s.size(); ++i) {
if (z[i] + i == s.size()) {
ans = max(ans, z[i]);
}
}
return ans;
}
string binary(ll n) {
string s;
while (n) {
if ((n & 1))
s += '1';
else
s += '0';
n >>= 1;
}
reverse(s.begin(), s.end());
return s;
}
bool pos(vector<ll> &v, ll val, ll painters) {
ll cur = 0;
ll k = 1;
for (int i = 0; i < v.size(); ++i) {
if (v[i] > val)
return 0;
if (cur + v[i] <= val)
cur += v[i];
else {
k++;
cur = v[i];
}
}
cout << k << endl;
return (k <= painters);
}
class node {
node *next;
node *random;
ll val;
node(ll x) {
next = random = NULL;
val = x;
}
};
ll dp[101][101][1001];
ll cal(ll a[], ll cur, ll n, ll sum, ll c, ll tot) {
if (n == 0) {
/// cout << cur << " " << sum << " " << c << endl;
if (cur == tot / 2)
return abs((sum - c) - c);
return 1e8;
}
if (dp[n][cur][c] != 1e8) {
/// cout << dp[n][cur][c] << " ";
return dp[n][cur][c];
}
/// cout << dp[n][cur][c] << " ";
dp[n][cur][c] = cal(a, cur, n - 1, sum, c, tot);
dp[n][cur][c] =
min(dp[n][cur][c], cal(a, cur + 1, n - 1, sum, c + a[n - 1], tot));
// cout << ans << endl;
return dp[n][cur][c];
}
void go() {
ll n;
cin >> n;
ll a[n];
for (int i = 0; i < n; ++i)
cin >> a[i];
ll dp[n];
// memset(dp , 0, sizeof dp);
for (int i = 0; i < n; ++i)
dp[i] = 1e8;
dp[0] = 0;
for (int i = 1; i < n; ++i) {
dp[i] = min(dp[i - 1] + abs(a[i] - a[i - 1]),
(i >= 2) ? dp[i - 2] + abs(a[i - 2] - a[i]) : (ll)1e8);
}
cout << dp[n - 1];
}
int main() {
fast;
online_judge();
go();
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define frst first
#define sec second
#define fast cin.tie(0), ios_base ::sync_with_stdio(0)
#define db double
#define mod 1000000007
void online_judge() {
#ifndef ONLINE_JUDGE
freopen("Input.txt", "r", stdin);
freopen("Output.txt", "w", stdout);
#endif
}
ll lpp(string s) {
string rev = s;
reverse(rev.begin(), rev.end());
s = s + '#' + rev;
////cout << s << " ";
vector<ll> z(s.size(), 0);
ll l = 0, r = 0;
for (int i = 1; i < s.size(); ++i) {
if (i > r) {
l = r = i;
while (s[r] == s[r - l]) {
r++;
}
z[i] = (r - l);
r--;
} else {
if (z[i - l] + i <= r)
z[i] = z[i - l];
else {
l = i;
while (s[r] == s[r - l])
r++;
z[i] = (r - l);
r--;
}
}
}
ll ans = 0;
for (int i = 0; i < s.size(); ++i) {
if (z[i] + i == s.size()) {
ans = max(ans, z[i]);
}
}
return ans;
}
string binary(ll n) {
string s;
while (n) {
if ((n & 1))
s += '1';
else
s += '0';
n >>= 1;
}
reverse(s.begin(), s.end());
return s;
}
bool pos(vector<ll> &v, ll val, ll painters) {
ll cur = 0;
ll k = 1;
for (int i = 0; i < v.size(); ++i) {
if (v[i] > val)
return 0;
if (cur + v[i] <= val)
cur += v[i];
else {
k++;
cur = v[i];
}
}
cout << k << endl;
return (k <= painters);
}
class node {
node *next;
node *random;
ll val;
node(ll x) {
next = random = NULL;
val = x;
}
};
ll dp[101][101][1001];
ll cal(ll a[], ll cur, ll n, ll sum, ll c, ll tot) {
if (n == 0) {
/// cout << cur << " " << sum << " " << c << endl;
if (cur == tot / 2)
return abs((sum - c) - c);
return 1e8;
}
if (dp[n][cur][c] != 1e8) {
/// cout << dp[n][cur][c] << " ";
return dp[n][cur][c];
}
/// cout << dp[n][cur][c] << " ";
dp[n][cur][c] = cal(a, cur, n - 1, sum, c, tot);
dp[n][cur][c] =
min(dp[n][cur][c], cal(a, cur + 1, n - 1, sum, c + a[n - 1], tot));
// cout << ans << endl;
return dp[n][cur][c];
}
void go() {
ll n;
cin >> n;
ll a[n];
for (int i = 0; i < n; ++i)
cin >> a[i];
ll dp[n];
// memset(dp , 0, sizeof dp);
for (int i = 0; i < n; ++i)
dp[i] = 1e8;
dp[0] = 0;
for (int i = 1; i < n; ++i) {
dp[i] = min(dp[i - 1] + abs(a[i] - a[i - 1]),
(i >= 2) ? dp[i - 2] + abs(a[i - 2] - a[i]) : (ll)1e8);
}
cout << dp[n - 1];
}
int main() {
fast;
// online_judge();
go();
}
| [
"call.remove"
] | 953,566 | 953,567 | u723601567 | cpp |
p03160 | #include <bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp>
// using namespace __gnu_pbds;
using namespace std;
#define int long long int
#define MOD 1000000007
#define pb push_back
#define mp make_pair
#define vi vector<int>
#define mi map<int, int>
#define umi unordered_map<int, int>
#define pii pair<int, int>
#define ff first
#define ss second
#define inf 1e18
#define case \
int t; \
cin >> t; \
while (t--)
// typedef tree<int, null_type, less<int>, rb_tree_tag,
// tree_order_statistics_node_update> pbds;
void pre() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
int32_t main() {
pre();
// case
{
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
if (n == 2) {
cout << abs(a[0] - a[1]);
return 0;
}
int dp[n];
dp[0] = 0;
dp[1] = abs(a[0] - a[1]);
for (int i = 2; i < n; i++) {
int s1 = dp[i - 1] + abs(a[i - 1] - a[i]);
int s2 = dp[i - 2] + abs(a[i - 2] - a[i]);
dp[i] = min(s1, s2);
}
cout << dp[n - 1];
}
return 0;
} | #include <bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp>
// using namespace __gnu_pbds;
using namespace std;
#define int long long int
#define MOD 1000000007
#define pb push_back
#define mp make_pair
#define vi vector<int>
#define mi map<int, int>
#define umi unordered_map<int, int>
#define pii pair<int, int>
#define ff first
#define ss second
#define inf 1e18
#define case \
int t; \
cin >> t; \
while (t--)
// typedef tree<int, null_type, less<int>, rb_tree_tag,
// tree_order_statistics_node_update> pbds;
void pre() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
int32_t main() { // pre();
// case
{
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
if (n == 2) {
cout << abs(a[0] - a[1]);
return 0;
}
int dp[n];
dp[0] = 0;
dp[1] = abs(a[0] - a[1]);
for (int i = 2; i < n; i++) {
int s1 = dp[i - 1] + abs(a[i - 1] - a[i]);
int s2 = dp[i - 2] + abs(a[i - 2] - a[i]);
dp[i] = min(s1, s2);
}
cout << dp[n - 1];
}
return 0;
} | [
"call.remove"
] | 953,570 | 953,571 | u959464076 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int height[n + 1];
int dp[n + 1];
for (int i = 1; i <= n; i++) {
scanf("%d", &height[i]);
}
dp[1] = 0;
dp[2] = abs(height[1] - height[2]);
for (int i = 3; i <= n; i++) {
dp[i] = max(dp[i - 1] + abs(height[i - 1] - height[i]),
dp[i - 2] + abs(height[i - 2] - height[i]));
}
printf("%d", dp[n]);
return 0;
} | #include <bits/stdc++.h>
/*
初始位置在石头1，要求跳到石头N
每一次可以跳1格或者2格，
每次从i跳到j，需要代价abs(height[i] - height[j])
求从1跳到N的最小代价
算法复杂度：O(n)
*/
using namespace std;
int main() {
int n;
scanf("%d", &n);
int height[n + 1];
int dp[n + 1];
for (int i = 1; i <= n; i++) {
scanf("%d", &height[i]);
}
dp[1] = 0;
dp[2] = abs(height[1] - height[2]);
for (int i = 3; i <= n; i++) {
dp[i] = min(dp[i - 1] + abs(height[i - 1] - height[i]),
dp[i - 2] + abs(height[i - 2] - height[i]));
}
printf("%d", dp[n]);
return 0;
} | [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 953,574 | 953,575 | u439850264 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int height[n + 1];
int dp[n + 1];
for (int i = 1; i <= n; i++) {
scanf("%d", &height[i]);
}
dp[1] = 0;
dp[2] = abs(height[1] - height[2]);
for (int i = 3; i <= n; i++) {
dp[i] = max(dp[i - 1] + abs(height[i - 1] - height[i]),
dp[i - 2] + abs(height[i - 2] - height[i]));
}
printf("%d", dp[n]);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int height[n + 1];
int dp[n + 1];
for (int i = 1; i <= n; i++) {
scanf("%d", &height[i]);
}
dp[1] = 0;
dp[2] = abs(height[1] - height[2]);
for (int i = 3; i <= n; i++) {
dp[i] = min(dp[i - 1] + abs(height[i - 1] - height[i]),
dp[i - 2] + abs(height[i - 2] - height[i]));
}
printf("%d", dp[n]);
return 0;
} | [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 953,574 | 953,576 | u439850264 | cpp |
p03160 | #include <bits/stdc++.h>
#include <stdint.h>
using namespace std;
#define int long long
#define pb push_back
#define mod 1000000007
#define endl '\n'
#define w(x) \
int x; \
cin >> x; \
while (x-- > 0)
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
void mysol() {
int n;
cin >> n;
int arr[n];
for (int &a : arr)
cin >> a;
int dp[n] = {0};
dp[0] = 0;
dp[1] = abs(arr[1] - arr[0]);
for (int i = 2; i < n; i++)
dp[i] = min(dp[i - 1] + abs(arr[i] - arr[i - 1]),
dp[i - 2] + abs(arr[i] - arr[i - 2]));
cout << dp[n - 1];
}
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 endl '\n'
#define w(x) \
int x; \
cin >> x; \
while (x-- > 0)
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
void mysol() {
int n;
cin >> n;
int arr[n];
for (int &a : arr)
cin >> a;
int dp[n] = {0};
dp[0] = 0;
dp[1] = abs(arr[1] - arr[0]);
for (int i = 2; i < n; i++)
dp[i] = min(dp[i - 1] + abs(arr[i] - arr[i - 1]),
dp[i - 2] + abs(arr[i] - arr[i - 2]));
cout << dp[n - 1];
}
int32_t main() {
// fast();
// w(t)
{ mysol(); }
return 0;
}
| [
"call.remove"
] | 953,581 | 953,582 | u464104383 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 5;
int main() {
int n, k;
cin >> n >> k;
vector<int> v(n);
for (int &x : v)
scanf("%d", &x);
vector<int> dp(n, INF);
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j : {i + 1, i + 2}) {
if (j < n) {
dp[j] = min(dp[j], dp[i] + abs(v[i] - v[j]));
}
}
}
printf("%d\n", dp[n - 1]);
}
| #include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 5;
int main() {
int n;
cin >> n;
vector<int> v(n);
for (int &x : v)
scanf("%d", &x);
vector<int> dp(n, INF);
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j : {i + 1, i + 2}) {
if (j < n) {
dp[j] = min(dp[j], dp[i] + abs(v[i] - v[j]));
}
}
}
printf("%d\n", dp[n - 1]);
}
| [
"variable_declaration.remove",
"expression.operation.binary.remove"
] | 953,583 | 953,584 | u339548494 | cpp |
p03160 | #include <algorithm>
#include <iostream>
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;
}
long long inf = 100000000000000;
int main() {
int n;
long long a[100005];
cin >> n;
int i;
for (i = 0; i < n; i++) {
cin >> a[i];
}
long long dp[100005];
for (i = 0; i < n; i++) {
dp[i] = inf;
}
dp[0] = 0;
for (i = 1; i < n; i++) {
chmin(dp[i], dp[i - 1] + abs(a[i] - a[i - 1])); // 一個飛ばしたとき //
if (i >= 2) { // iが1の時しないようにする //
chmin(dp[i], dp[i - 1] + abs(a[i] - a[i - 2])); // 二個飛ばしたとき //
}
}
cout << dp[n - 1]; // n-1個目のdpが最小値 //
return (0);
} | #include <algorithm>
#include <iostream>
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;
}
long long inf = 100000000000000;
int main() {
int n;
long long a[100005];
cin >> n;
int i;
for (i = 0; i < n; i++) {
cin >> a[i];
}
long long dp[100005];
for (i = 0; i < n; i++) {
dp[i] = inf;
}
dp[0] = 0;
for (i = 1; i < n; i++) {
chmin(dp[i], dp[i - 1] + abs(a[i] - a[i - 1])); // 一個飛ばしたとき //
if (i >= 2) { // iが1の時しないようにする //
chmin(dp[i], dp[i - 2] + abs(a[i] - a[i - 2])); // 二個飛ばしたとき //
}
}
cout << dp[n - 1]; // n-1個目のdpが最小値 //
return (0);
} | [
"literal.number.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 953,591 | 953,592 | u836743234 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int h[n], i;
for (i = 0; i < n; i++)
cin >> h[i];
int a = 0, b = abs(h[1] - h[0]), c;
i = 2;
while (i < n) {
c = min(abs(h[i] - h[i - 1]) + b, abs(h[i] - h[i - 2]) + a);
a = b;
b = c;
i++;
}
cout << c << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int h[n], i;
for (i = 0; i < n; i++)
cin >> h[i];
int a = 0, b = abs(h[1] - h[0]), c = b;
i = 2;
while (i < n) {
c = min(abs(h[i] - h[i - 1]) + b, abs(h[i] - h[i - 2]) + a);
a = b;
b = c;
i++;
}
// if(n == 2) cout << b << endl;
cout << c << endl;
return 0;
}
| [
"variable_declaration.value.change"
] | 953,593 | 953,594 | u554798265 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define IOS \
std::cin.tie(0); \
std::ios_base::sync_with_stdio(false)
#define ll long long
#define Fi first
#define Se second
#define Pb push_back
#define vi vector<int>
#define vp vector<pair<int, int>>
#define vvi vector<vector<int>>
#define vvp vector<vector<pair<int, int>>>
using Graph = vector<vector<int>>;
#define sz(x) (int)x.size()
#define all(v) v.begin(), v.end()
#define output_s(s) printf("%s\n", (s).c_str())
#define END cout << "\n"
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define Rep(i, n, m) for (int i = (int)(n); i < (int)(m); i++)
#define RepS(i, n, m) for (int i = (int)(n); i <= (int)(m); i++)
#define RRepS(i, n, m) for (int i = (int)(n); i >= (int)(m); i--)
#define SRepS(i, n, m) for (int i = (int)(n); i * i <= (int)(m); i++)
#define RepA(x) for (auto &item : (x))
void CINT() {} //@shibh308's template
template <class Head, class... Tail> void CINT(Head &&head, Tail &&...tail) {
cin >> head;
CINT(move(tail)...);
}
#define CIN(...) \
int __VA_ARGS__; \
CINT(__VA_ARGS__)
#define LCIN(...) \
ll __VA_ARGS__; \
CINT(__VA_ARGS__)
#define SCIN(...) \
string __VA_ARGS__; \
CINT(__VA_ARGS__)
#define VCIN(x) \
for (auto &item : x) \
cin >> item
void OUT() {}
template <class Head, class... Tail> void OUT(Head &&head, Tail &&...tail) {
cout << head << (sizeof...(tail) ? " " : "\n");
OUT(move(tail)...);
}
#define COUT(...) OUT(__VA_ARGS__)
template <typename TypeInt> TypeInt GCD(TypeInt a, TypeInt b) {
return a % b == 0 ? b : GCD(b, a % b);
} //最大公約数
template <typename TypeInt> TypeInt LCM(TypeInt a, TypeInt b) {
return a * b / GCD(a, b);
} //最小公倍数
template <class T> inline bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
template <class T> bool comp(T a, T b) { return abs(a) < abs(b); } //比較関数
void YES(bool f) { printf(f ? "YES\n" : "NO\n"); }
void Yes(bool f) { printf(f ? "Yes\n" : "No\n"); }
void Possible(bool f) { printf(f ? "Possible\n" : "Impossible\n"); }
void POSSIBLE(bool f) { printf(f ? "POSSIBLE\n" : "IMPOSSIBLE\n"); }
//----------------------library------------------------//
// const int dx[4]={1,0,-1,0};
// const int dy[4]={0,1,0,-1};
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
const int NMAX = 55;
const int INF = 1e9;
const int MOD = 1e9 + 7;
bool flag;
//----------------------Global-------------------------//
signed main() {
CIN(N);
vi H(N);
VCIN(H);
vi dp(N + 10, 0);
dp[0] = 0;
dp[1] = abs(H[1] - H[0]);
Rep(i, 2, N) {
dp[i] =
min(abs(dp[i - 2] + H[i - 2] - H[i]), dp[i - 2] + abs(H[i - 1] - H[i]));
}
COUT(dp[N - 1]);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define IOS \
std::cin.tie(0); \
std::ios_base::sync_with_stdio(false)
#define ll long long
#define Fi first
#define Se second
#define Pb push_back
#define vi vector<int>
#define vp vector<pair<int, int>>
#define vvi vector<vector<int>>
#define vvp vector<vector<pair<int, int>>>
using Graph = vector<vector<int>>;
#define sz(x) (int)x.size()
#define all(v) v.begin(), v.end()
#define output_s(s) printf("%s\n", (s).c_str())
#define END cout << "\n"
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define Rep(i, n, m) for (int i = (int)(n); i < (int)(m); i++)
#define RepS(i, n, m) for (int i = (int)(n); i <= (int)(m); i++)
#define RRepS(i, n, m) for (int i = (int)(n); i >= (int)(m); i--)
#define SRepS(i, n, m) for (int i = (int)(n); i * i <= (int)(m); i++)
#define RepA(x) for (auto &item : (x))
void CINT() {} //@shibh308's template
template <class Head, class... Tail> void CINT(Head &&head, Tail &&...tail) {
cin >> head;
CINT(move(tail)...);
}
#define CIN(...) \
int __VA_ARGS__; \
CINT(__VA_ARGS__)
#define LCIN(...) \
ll __VA_ARGS__; \
CINT(__VA_ARGS__)
#define SCIN(...) \
string __VA_ARGS__; \
CINT(__VA_ARGS__)
#define VCIN(x) \
for (auto &item : x) \
cin >> item
void OUT() {}
template <class Head, class... Tail> void OUT(Head &&head, Tail &&...tail) {
cout << head << (sizeof...(tail) ? " " : "\n");
OUT(move(tail)...);
}
#define COUT(...) OUT(__VA_ARGS__)
template <typename TypeInt> TypeInt GCD(TypeInt a, TypeInt b) {
return a % b == 0 ? b : GCD(b, a % b);
} //最大公約数
template <typename TypeInt> TypeInt LCM(TypeInt a, TypeInt b) {
return a * b / GCD(a, b);
} //最小公倍数
template <class T> inline bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
template <class T> bool comp(T a, T b) { return abs(a) < abs(b); } //比較関数
void YES(bool f) { printf(f ? "YES\n" : "NO\n"); }
void Yes(bool f) { printf(f ? "Yes\n" : "No\n"); }
void Possible(bool f) { printf(f ? "Possible\n" : "Impossible\n"); }
void POSSIBLE(bool f) { printf(f ? "POSSIBLE\n" : "IMPOSSIBLE\n"); }
//----------------------library------------------------//
// const int dx[4]={1,0,-1,0};
// const int dy[4]={0,1,0,-1};
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
const int NMAX = 55;
const int INF = 1e9;
const int MOD = 1e9 + 7;
bool flag;
//----------------------Global-------------------------//
signed main() {
CIN(N);
vi H(N);
VCIN(H);
vi dp(N + 10, 0);
dp[0] = 0;
dp[1] = abs(H[1] - H[0]);
Rep(i, 2, N) {
dp[i] =
min(dp[i - 2] + abs(H[i - 2] - H[i]), dp[i - 1] + abs(H[i - 1] - H[i]));
}
COUT(dp[N - 1]);
return 0;
} | [
"call.arguments.change",
"call.add",
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 953,599 | 953,600 | u960080897 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define endl '\n'
#define vi vector<ll>
#define vb vector<bool>
#define pii pair<ll, ll>
#define mod 1000000007
#define pll pair<ll, ll>
#define rep(i, n) for (ll i = 0; i < n; i++)
#define per(i, n) for (ll i = n - 1; i >= 0; i--)
#define rep1(i, n) for (ll i = 1; i <= n; i++)
#define per1(i, n) for (ll i = n; i > 0; i--)
#define prll(a, n) \
for (ll i = 0; i < n; i++) { \
cout << a[i] << " "; \
}
#define ain(a) \
for (auto &i : a) \
cin >> i
#define mms(a) memset(a, 0, sizeof(a))
// cout << fixed << setprecision(0) << pi <<" "<<npi<<endl;
ll max_ll(ll a, ll b, ll c) { return max(a, max(b, c)); }
ll min_ll(ll a, ll b, ll c) { return min(a, min(b, c)); }
bool sortBySec(pair<ll, ll> a, pair<ll, ll> b) {
if (a.second == b.second)
return a.first < b.first;
return (a.second < b.second);
}
long long binexpmod(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) {
res = res * a % mod;
}
a = a * a % mod;
b >>= 1;
}
return (res);
}
ll lcm(ll a, ll b) {
ll x = __gcd(a, b);
a /= x;
b /= x;
ll sum = a * b * x;
return sum;
}
void solve() {
ll n, res = 0;
cin >> n;
vi a(n);
ain(a);
ll dp1[n];
dp1[0] = 0;
dp1[1] = a[1] - a[0];
for (ll i = 2; i < n; i++) {
dp1[i] = min(dp1[i - 1] + abs(a[i] - a[i - 1]),
dp1[i - 2] + abs(a[i] - a[i - 2]));
}
cout << dp1[n - 1] << endl;
return;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll t = 1;
// cin>>t;
while (t--) {
solve();
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define endl '\n'
#define vi vector<ll>
#define vb vector<bool>
#define pii pair<ll, ll>
#define mod 1000000007
#define pll pair<ll, ll>
#define rep(i, n) for (ll i = 0; i < n; i++)
#define per(i, n) for (ll i = n - 1; i >= 0; i--)
#define rep1(i, n) for (ll i = 1; i <= n; i++)
#define per1(i, n) for (ll i = n; i > 0; i--)
#define prll(a, n) \
for (ll i = 0; i < n; i++) { \
cout << a[i] << " "; \
}
#define ain(a) \
for (auto &i : a) \
cin >> i
#define mms(a) memset(a, 0, sizeof(a))
// cout << fixed << setprecision(0) << pi <<" "<<npi<<endl;
ll max_ll(ll a, ll b, ll c) { return max(a, max(b, c)); }
ll min_ll(ll a, ll b, ll c) { return min(a, min(b, c)); }
bool sortBySec(pair<ll, ll> a, pair<ll, ll> b) {
if (a.second == b.second)
return a.first < b.first;
return (a.second < b.second);
}
long long binexpmod(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) {
res = res * a % mod;
}
a = a * a % mod;
b >>= 1;
}
return (res);
}
ll lcm(ll a, ll b) {
ll x = __gcd(a, b);
a /= x;
b /= x;
ll sum = a * b * x;
return sum;
}
void solve() {
ll n, res = 0;
cin >> n;
vi a(n);
ain(a);
ll dp1[n];
dp1[0] = 0;
dp1[1] = abs(a[1] - a[0]);
for (ll i = 2; i < n; i++) {
dp1[i] = min(dp1[i - 1] + abs(a[i] - a[i - 1]),
dp1[i - 2] + abs(a[i] - a[i - 2]));
}
cout << dp1[n - 1] << endl;
return;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll t = 1;
// cin>>t;
while (t--) {
solve();
}
return 0;
} | [
"call.add",
"call.arguments.change"
] | 953,603 | 953,604 | u720542798 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define int long long
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
int arr[n + 1];
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
int dp[n + 1];
dp[0] = dp[1] = 0;
dp[2] = abs(arr[1] - arr[0]);
for (int i = 3; i <= n; i++) {
dp[i] = min(dp[i - 1] + abs(arr[i] - arr[i - 1]),
dp[i - 2] + abs(arr[i] - arr[i - 2]));
}
cout << dp[n] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
int arr[n + 1];
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
int dp[n + 1];
dp[0] = dp[1] = 0;
dp[2] = abs(arr[2] - arr[1]);
for (int i = 3; i <= n; i++) {
dp[i] = min(dp[i - 1] + abs(arr[i] - arr[i - 1]),
dp[i - 2] + abs(arr[i] - arr[i - 2]));
}
cout << dp[n] << endl;
return 0;
} | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 953,605 | 953,606 | u862953056 | cpp |
p03160 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
const int INF = 1001001001;
using namespace std;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> h(n);
rep(i, n) cin >> h[i];
vector<int> dp(n, INF);
dp[0] = 0;
dp[1] = abs(h[0] - h[1]);
/*for(int i=2; i<n; i++) {
for (int j=0; j<j; j++) {
}
dp[i] = min(dp[i-1]+abs(h[i]-h[i-1]), dp[i-2]+abs(h[i]-h[i-2]));
}*/
for (int i = 0; i < n; i++) {
dp[i + 2] =
min(dp[i + 1] + abs(h[i + 1] - h[i + 2]), dp[i] + abs(h[i] - h[i + 2]));
}
cout << dp[n - 1] << "\n";
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
const int INF = 1001001001;
using namespace std;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> h(n);
rep(i, n) cin >> h[i];
vector<int> dp(n + 2, INF);
dp[0] = 0;
dp[1] = abs(h[0] - h[1]);
/*for(int i=2; i<n; i++) {
for (int j=0; j<j; j++) {
}
dp[i] = min(dp[i-1]+abs(h[i]-h[i-1]), dp[i-2]+abs(h[i]-h[i-2]));
}*/
for (int i = 0; i < n; i++) {
dp[i + 2] =
min(dp[i + 1] + abs(h[i + 1] - h[i + 2]), dp[i] + abs(h[i] - h[i + 2]));
}
cout << dp[n - 1] << "\n";
return 0;
} | [
"assignment.change"
] | 953,609 | 953,610 | u786667376 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
int dp[n];
dp[0] = a[0];
dp[1] = abs(a[1] - a[0]);
for (int i = 2; i < n; i++) {
dp[i] =
min(dp[i - 2] + abs(a[i] - a[i - 2]), dp[i - 1] + abs(a[i] - a[i - 1]));
}
cout << dp[n - 1] << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
int dp[n];
dp[0] = 0;
dp[1] = abs(a[1] - a[0]);
for (int i = 2; i < n; i++) {
dp[i] =
min(dp[i - 2] + abs(a[i] - a[i - 2]), dp[i - 1] + abs(a[i] - a[i - 1]));
// cout<<dp[i]<<" ";
}
cout << dp[n - 1] << endl;
} | [] | 953,620 | 953,621 | u788146497 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
int dp[n];
dp[0] = a[0];
dp[1] = abs(a[1] - a[0]);
for (int i = 2; i < n; i++) {
dp[i] =
max(dp[i - 2] + abs(a[i] - a[i - 2]), dp[i - 1] + abs(a[i] - a[i - 1]));
}
cout << dp[n - 1] << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
int dp[n];
dp[0] = 0;
dp[1] = abs(a[1] - a[0]);
for (int i = 2; i < n; i++) {
dp[i] =
min(dp[i - 2] + abs(a[i] - a[i - 2]), dp[i - 1] + abs(a[i] - a[i - 1]));
// cout<<dp[i]<<" ";
}
cout << dp[n - 1] << endl;
} | [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 953,622 | 953,621 | u788146497 | cpp |
p03160 | //<============ Author --> @venom ============>//
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace std;
using namespace __gnu_pbds;
#define fo(i, n) for (int i = 0; i < n; i++)
#define int long long
#define pb emplace_back
#define mp make_pair
#define ff first
#define ss second
#define all(x) x.begin(), x.end()
#define sortall(x) sort(all(x))
#define sortrev(x) sort(all(x), greater<int>())
#define w(x) \
int x; \
cin >> x; \
while (x--)
#define trunc(x, y) fixed << setprecision(y) << x
#define mk(arr, n, type) type *arr = new type[n];
#define PI 3.1415926535897932384626
#define mod 1000000007
#define inf 1e18
#define FIO \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
typedef pair<int, int> pi;
typedef vector<int> vi;
typedef vector<pi> vpi;
typedef vector<vi> vvi;
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
indexed_set;
const int N = 3e5, M = N;
int mpow(int base, int exp);
int gcd(int a, int b) {
if (a == 0)
return b;
return gcd(b % a, a);
}
//<----------------------------------------------------------------------------->//
void fastIO() {
FIO;
#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
}
int32_t main() {
fastIO();
int n;
cin >> n;
int x;
vi h;
fo(i, n) {
cin >> x;
h.pb(x);
}
vi dp(n, inf);
dp[0] = 0;
fo(i, n) {
for (int j : {i + 1, i + 2}) {
if (j < n) {
dp[j] = min(dp[j], dp[i] + abs(h[i] - h[j]));
}
}
}
cout << dp[n - 1] << "\n";
return 0;
}
int mpow(int base, int exp) {
base %= mod;
int result = 1;
while (exp > 0) {
if (exp & 1)
result = ((int)result * base) % mod;
base = ((int)base * base) % mod;
exp >>= 1;
}
return result;
} | //<============ Author --> @venom ============>//
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace std;
using namespace __gnu_pbds;
#define fo(i, n) for (int i = 0; i < n; i++)
#define int long long
#define pb emplace_back
#define mp make_pair
#define ff first
#define ss second
#define all(x) x.begin(), x.end()
#define sortall(x) sort(all(x))
#define sortrev(x) sort(all(x), greater<int>())
#define w(x) \
int x; \
cin >> x; \
while (x--)
#define trunc(x, y) fixed << setprecision(y) << x
#define mk(arr, n, type) type *arr = new type[n];
#define PI 3.1415926535897932384626
#define mod 1000000007
#define inf 1e18
#define FIO \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
typedef pair<int, int> pi;
typedef vector<int> vi;
typedef vector<pi> vpi;
typedef vector<vi> vvi;
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
indexed_set;
const int N = 3e5, M = N;
int mpow(int base, int exp);
int gcd(int a, int b) {
if (a == 0)
return b;
return gcd(b % a, a);
}
//<----------------------------------------------------------------------------->//
void fastIO() {
FIO;
#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
}
int32_t main() {
FIO;
int n;
cin >> n;
int x;
vi h;
fo(i, n) {
cin >> x;
h.pb(x);
}
vi dp(n, inf);
dp[0] = 0;
fo(i, n) {
for (int j : {i + 1, i + 2}) {
if (j < n) {
dp[j] = min(dp[j], dp[i] + abs(h[i] - h[j]));
}
}
}
cout << dp[n - 1] << "\n";
return 0;
}
int mpow(int base, int exp) {
base %= mod;
int result = 1;
while (exp > 0) {
if (exp & 1)
result = ((int)result * base) % mod;
base = ((int)base * base) % mod;
exp >>= 1;
}
return result;
} | [
"call.arguments.change"
] | 953,625 | 953,626 | u712465155 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
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 = pow(10, 6);
long long h[100010];
long long dp[100010];
int main() {
int N;
cin >> N;
for (int i = 0; i < N; ++i)
cin >> h[i];
for (int i = 0; i < 100010; ++i)
dp[i] = INF;
dp[0] = 0;
for (int i = 1; i < N; ++i) {
chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
if (i > 1)
chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
// answer
cout << dp[N - 1] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
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 = pow(10, 9);
long long h[100010];
long long dp[100010];
int main() {
int N;
cin >> N;
for (int i = 0; i < N; ++i)
cin >> h[i];
for (int i = 0; i < 100010; ++i)
dp[i] = INF;
dp[0] = 0;
for (int i = 1; i < N; ++i) {
chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
if (i > 1)
chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
// answer
cout << dp[N - 1] << endl;
return 0;
}
| [
"literal.number.change",
"call.arguments.change"
] | 953,644 | 953,645 | u095360661 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define ll long long
#define INF 1000000000000000000
#define all(x) x.begin(), x.end()
#define PI 3.141592653589793
int main() {
int N;
cin >> N;
vector<int> H(N);
rep(i, N) { cin >> H[i]; }
vector<int> dp(N, 1e6);
dp[0] = 0;
dp[1] = abs(H[1] - H[0]);
for (int i = 2; i < N; i++) {
dp[i] = min(dp[i], dp[i - 1] + abs(H[i] - H[i - 1]));
dp[i] = min(dp[i], dp[i - 2] + abs(H[i] - H[i - 2]));
}
cout << dp[N - 1] << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define ll long long
#define INF 1000000000000000000
#define all(x) x.begin(), x.end()
#define PI 3.141592653589793
int main() {
int N;
cin >> N;
vector<ll> H(N);
rep(i, N) { cin >> H[i]; }
vector<ll> dp(N, INF);
dp[0] = 0;
dp[1] = abs(H[1] - H[0]);
for (int i = 2; i < N; i++) {
dp[i] = min(dp[i], dp[i - 1] + abs(H[i] - H[i - 1]));
dp[i] = min(dp[i], dp[i - 2] + abs(H[i] - H[i - 2]));
}
cout << dp[N - 1] << endl;
} | [
"call.arguments.change"
] | 953,646 | 953,647 | u115454768 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
using namespace std::chrono;
int arr[100005];
int n;
long long dp[100005];
/*long long go(int i){
if(i == n-1)
return 0;
if(i >= n)
return 1000000;
int &ans = dp[i];
if(ans!=-1)
return ans;
ans = min(abs(arr[i] - arr[i+1]) + go(i+1) , abs(arr[i] - arr[i+2]) +
go(i+2)); return ans;
}*/
int main() {
// auto start = high_resolution_clock::now();
cin >> n;
for (int i = 1; i <= n; i++)
cin >> arr[i];
dp[0] = 0;
dp[1] = 0;
for (int i = 2; i <= n; i++) {
dp[i] = min(dp[i - 2] + abs(arr[i - 2] - arr[i]),
dp[i - 1] + abs(arr[i - 1] - arr[i]));
}
cout << dp[n];
// auto stop = high_resolution_clock::now();
// auto duration = duration_cast<milliseconds>(stop - start);
// cout<<duration.count();
}
| #include <bits/stdc++.h>
using namespace std;
using namespace std::chrono;
int arr[100005];
int n;
long long dp[100005];
int main() {
// auto start = high_resolution_clock::now();
cin >> n;
for (int i = 1; i <= n; i++)
cin >> arr[i];
dp[0] = 100000;
dp[1] = 0;
for (int i = 2; i <= n; i++) {
dp[i] = min(dp[i - 2] + abs(arr[i - 2] - arr[i]),
dp[i - 1] + abs(arr[i - 1] - arr[i]));
}
cout << dp[n];
}
| [
"literal.number.change",
"assignment.value.change"
] | 953,648 | 953,649 | u163562872 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define repx(x, i, n) for (int i = x; i < n; i++)
#define rep(i, n) repx(0, i, n)
#define all(x) x.begin(), x.end()
signed main() {
ll N;
cin >> N;
ll h[N];
ll DP[N];
rep(i, N) cin >> h[i];
DP[0] = 0;
DP[1] = abs(h[1] - h[0]);
rep(i, N) {
DP[i] =
min(DP[i - 1] + abs(h[i] - h[i - 1]), DP[i - 2] + abs(h[i] - h[i - 2]));
}
cout << DP[N - 1] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define repx(x, i, n) for (int i = x; i < n; i++)
#define rep(i, n) repx(0, i, n)
#define all(x) x.begin(), x.end()
signed main() {
ll N;
cin >> N;
ll h[N];
ll DP[N];
rep(i, N) cin >> h[i];
DP[0] = 0;
DP[1] = abs(h[1] - h[0]);
repx(2, i, N) {
DP[i] =
min(DP[i - 1] + abs(h[i] - h[i - 1]), DP[i - 2] + abs(h[i] - h[i - 2]));
}
cout << DP[N - 1] << endl;
return 0;
}
| [
"call.arguments.add"
] | 953,652 | 953,653 | u855838587 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define repx(x, i, n) for (int i = x; i < n; i++)
#define rep(i, n) repx(0, i, n)
#define all(x) x.begin(), x.end()
signed main() {
ll N;
cin >> N;
ll h[N + 10] = {0};
ll DP[N + 10] = {0};
repx(1, i, N + 1) cin >> h[i];
DP[2] = h[2] - h[1];
repx(3, i, N + 1) {
DP[i] =
min(DP[i - 1] + abs(h[i] - h[i - 1]), DP[i - 2] + abs(h[i] - h[i - 2]));
}
cout << DP[N] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define repx(x, i, n) for (int i = x; i < n; i++)
#define rep(i, n) repx(0, i, n)
#define all(x) x.begin(), x.end()
signed main() {
ll N;
cin >> N;
ll h[N + 10] = {0};
ll DP[N + 10] = {0};
repx(1, i, N + 1) cin >> h[i];
DP[2] = abs(h[2] - h[1]);
repx(3, i, N + 1) {
DP[i] =
min(DP[i - 1] + abs(h[i] - h[i - 1]), DP[i - 2] + abs(h[i] - h[i - 2]));
}
cout << DP[N] << endl;
return 0;
}
| [
"call.add",
"call.arguments.change"
] | 953,654 | 953,655 | u855838587 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int height[N];
int ans[N];
for (int i = 0; i < N; i++) {
cin >> height[i];
}
ans[0] = 0;
ans[1] = abs(height[1] - height[0]);
for (int i = 2; i < N; i++) {
ans[i] = min(ans[i - 1] + abs(height[i] - height[i - 1]),
ans[i - 2] + abs(height[i] - height[i - 2]));
}
cout << ans[N];
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int height[N];
int ans[N];
for (int i = 0; i < N; i++) {
cin >> height[i];
}
ans[0] = 0;
ans[1] = abs(height[1] - height[0]);
for (int i = 2; i < N; i++) {
ans[i] = min(ans[i - 1] + abs(height[i] - height[i - 1]),
ans[i - 2] + abs(height[i] - height[i - 2]));
}
cout << ans[N - 1];
} | [
"expression.operation.binary.add"
] | 953,656 | 953,657 | u052165189 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n + 1];
for (int i = 1; i <= n; i++)
cin >> arr[i];
int dp[n + 1];
dp[1] = 0;
dp[2] = abs(arr[1] - arr[0]);
for (int i = 3; i <= n; i++)
dp[i] = min(dp[i - 1] + abs(arr[i] - arr[i - 1]),
dp[i - 2] + abs(arr[i] - arr[i - 2]));
cout << dp[n] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n + 1];
for (int i = 1; i <= n; i++)
cin >> arr[i];
int dp[n + 1];
dp[1] = 0;
dp[2] = abs(arr[2] - arr[1]);
for (int i = 3; i <= n; i++)
dp[i] = min(dp[i - 1] + abs(arr[i] - arr[i - 1]),
dp[i - 2] + abs(arr[i] - arr[i - 2]));
cout << dp[n] << endl;
return 0;
} | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 953,662 | 953,663 | u309191974 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n + 1];
for (int i = 0; i <= n; i++)
cin >> arr[i];
int dp[n + 1];
dp[1] = 0;
dp[2] = abs(arr[1] - arr[0]);
for (int i = 3; i <= n; i++)
dp[i] = min(dp[i - 1] + abs(arr[i] - arr[i - 1]),
dp[i - 2] + abs(arr[i] - arr[i - 2]));
cout << dp[n] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n + 1];
for (int i = 1; i <= n; i++)
cin >> arr[i];
int dp[n + 1];
dp[1] = 0;
dp[2] = abs(arr[2] - arr[1]);
for (int i = 3; i <= n; i++)
dp[i] = min(dp[i - 1] + abs(arr[i] - arr[i - 1]),
dp[i - 2] + abs(arr[i] - arr[i - 2]));
cout << dp[n] << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 953,664 | 953,663 | u309191974 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define fo(i, n) for (i = 0; i < n; i++)
#define of(i, n) for (i = n - 1; i >= 0; i--)
#define ll long long
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long k = 0, t = 0, i = 0, mex = 0, e = 0, cnt = 0;
ll n, m;
cin >> n;
int a[n], dp[n];
fo(i, n) cin >> a[i];
dp[n - 2] = abs(a[n - 1] - a[n - 2]);
dp[n - 1] = 0;
for (i = n - 1; i >= 1; --i) {
dp[i - 2] =
min(dp[i - 1] + abs(a[i] - a[i - 1]), dp[i] + abs(a[i] - a[i - 2]));
}
cout << dp[0];
}
| #include <bits/stdc++.h>
using namespace std;
#define fo(i, n) for (i = 0; i < n; i++)
#define of(i, n) for (i = n - 1; i >= 0; i--)
#define ll long long
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long k = 0, t = 0, i = 0, mex = 0, e = 0, cnt = 0;
ll n, m;
cin >> n;
int a[n], dp[n];
fo(i, n) cin >> a[i];
dp[n - 2] = abs(a[n - 1] - a[n - 2]);
dp[n - 1] = 0;
for (i = n - 1; i >= 1; --i) {
dp[i - 2] =
min(dp[i - 1] + abs(a[i - 1] - a[i - 2]), dp[i] + abs(a[i] - a[i - 2]));
}
cout << dp[0];
}
| [
"assignment.change",
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 953,665 | 953,666 | u744956225 | cpp |
p03160 | /*# # # # # # # # # # # # # # # # # # #
# # # # # # # # #
# # # # # ## # # # # # ## # # # # # # # # # # # # # ##
# # # # # # # # #
# # # # # # # # # # # # #*/
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define int long long
#define mkp make_pair
#define pb push_back
#define ff first
#define ss second
#define debug1(a) cout << a << endl;
#define debug2(a, b) cout << a << ' ' << b << endl;
#define debug3(a, b, c) cout << a < ' ' << b << ' ' << c << endl;
#define rep(i, n) for (int i = 0; i < n; i++)
#define repr(i, a, b) for (int i = a; i < b; i++)
#define repre(i, a, b) for (int i = a; i <= b; i++)
#define pi pair<int, int>
#define pii pair<int, pi>
#define mp map<int, int>
#define iofile \
freopen("input.txt", "r", stdin); \
freopen("output.txt", "w", stdout);
#define ump unordered_map<int, int>
#define st set<int>
#define ust unordered_set<int>
#define mst multiset<int>
#define pq priority_queue
#define mpq priority_queue<int, vector<int>, greater<int>>
#define fastio \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define sumofdigits(sum, num) \
int sum = 0; \
while (n != 0) { \
sum = sum + n % 10; \
n = n / 10; \
}
#define int2str(str, n) n = boost::lexical_cast<int>(str);
#define float2str(str, n) n = boost::lexical_cast<float>(str);
using namespace __gnu_pbds;
using namespace std;
#define Endl endl
#define ar(n) int h[n]
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
orderedSet;
typedef tree<int, null_type, less_equal<int>, rb_tree_tag,
tree_order_statistics_node_update>
orderedMSet;
//*p.find_by_order(index) return value at index
// p.order_of_key(key) return index
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int32_t main() {
fastio int tcase = 1;
// cin>>tcase;
while (tcase--) {
int n;
cin >> n;
int h[n], dp[n];
rep(i, n) cin >> h[i];
memset(dp, 0, sizeof(dp));
dp[2] = abs(h[1] - h[0]);
repr(i, 2, n) {
dp[i] = min(dp[i - 2] + abs(h[i] - h[i - 2]),
dp[i - 1] + abs(h[i] - h[i - 1]));
}
cout << dp[n - 1] << endl;
}
return 0;
}
bool isPrime(int n) {
if (n <= 1)
return false;
if (n <= 3)
return true;
if (n % 2 == 0 || n % 3 == 0)
return false;
int p = sqrt(n);
for (int i = 5; i <= p; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
int binpow(int a, int b) {
int res = 1;
while (b > 0) {
if (b & 1)
res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
| /*# # # # # # # # # # # # # # # # # # #
# # # # # # # # #
# # # # # ## # # # # # ## # # # # # # # # # # # # # ##
# # # # # # # # #
# # # # # # # # # # # # #*/
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define int long long
#define mkp make_pair
#define pb push_back
#define ff first
#define ss second
#define debug1(a) cout << a << endl;
#define debug2(a, b) cout << a << ' ' << b << endl;
#define debug3(a, b, c) cout << a < ' ' << b << ' ' << c << endl;
#define rep(i, n) for (int i = 0; i < n; i++)
#define repr(i, a, b) for (int i = a; i < b; i++)
#define repre(i, a, b) for (int i = a; i <= b; i++)
#define pi pair<int, int>
#define pii pair<int, pi>
#define mp map<int, int>
#define iofile \
freopen("input.txt", "r", stdin); \
freopen("output.txt", "w", stdout);
#define ump unordered_map<int, int>
#define st set<int>
#define ust unordered_set<int>
#define mst multiset<int>
#define pq priority_queue
#define mpq priority_queue<int, vector<int>, greater<int>>
#define fastio \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define sumofdigits(sum, num) \
int sum = 0; \
while (n != 0) { \
sum = sum + n % 10; \
n = n / 10; \
}
#define int2str(str, n) n = boost::lexical_cast<int>(str);
#define float2str(str, n) n = boost::lexical_cast<float>(str);
using namespace __gnu_pbds;
using namespace std;
#define Endl endl
#define ar(n) int h[n]
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
orderedSet;
typedef tree<int, null_type, less_equal<int>, rb_tree_tag,
tree_order_statistics_node_update>
orderedMSet;
//*p.find_by_order(index) return value at index
// p.order_of_key(key) return index
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int32_t main() {
fastio int tcase = 1;
// cin>>tcase;
while (tcase--) {
int n;
cin >> n;
int h[n], dp[n];
rep(i, n) cin >> h[i];
memset(dp, 0, sizeof(dp));
dp[1] = abs(h[1] - h[0]);
repr(i, 2, n) {
dp[i] = min(dp[i - 2] + abs(h[i] - h[i - 2]),
dp[i - 1] + abs(h[i] - h[i - 1]));
}
cout << dp[n - 1] << endl;
}
return 0;
}
bool isPrime(int n) {
if (n <= 1)
return false;
if (n <= 3)
return true;
if (n % 2 == 0 || n % 3 == 0)
return false;
int p = sqrt(n);
for (int i = 5; i <= p; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
int binpow(int a, int b) {
int res = 1;
while (b > 0) {
if (b & 1)
res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
| [
"literal.number.change",
"assignment.variable.change",
"variable_access.subscript.index.change"
] | 953,667 | 953,668 | u600992329 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define ull unsigned long long
#define MOD (int)(998244353)
#define ceil(x, y) (x % y == 0 ? (x / y) : (x / y + 1))
#define FOR(i, N) for (int i = 0; i < N; ++i)
#define FOR1(i, N) for (int i = 1; i <= N; ++i)
#define vi vector<int>
#define pii pair<int, int>
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define mset(a, v) memset(a, v, sizeof(a))
#define all(v) (v).begin(), (v).end()
#define INF 2e18
#define EPS 1e-9
#define int long long
#define MAX 100009
int fun(int arr[], int n) {
/*if(n == 1) return 0LL;
if(n == 2) return abs(arr[n]-arr[n-1]);
return min(abs(arr[n]-arr[n-1]) + fun(arr, n-1), abs(arr[n]-arr[n-2]) + fun(arr,
n-2));*/
int dp[n + 1];
dp[1] = 0LL;
dp[2] = abs(arr[n] - arr[n - 1]);
for (int i = 3; i <= n; i++) {
dp[i] = min(abs(arr[i] - arr[i - 1]) + dp[i - 1],
abs(arr[i] - arr[i - 2]) + dp[i - 2]);
}
return dp[n];
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int T = 1;
// cin >> T;
FOR1(i, T) {
// cout << "Case #" << i << ": \n";
int n;
cin >> n;
int a[n + 1];
FOR1(i, n) cin >> a[i];
cout << fun(a, n);
cout << '\n';
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ull unsigned long long
#define MOD (int)(998244353)
#define ceil(x, y) (x % y == 0 ? (x / y) : (x / y + 1))
#define FOR(i, N) for (int i = 0; i < N; ++i)
#define FOR1(i, N) for (int i = 1; i <= N; ++i)
#define vi vector<int>
#define pii pair<int, int>
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define mset(a, v) memset(a, v, sizeof(a))
#define all(v) (v).begin(), (v).end()
#define INF 2e18
#define EPS 1e-9
#define int long long
#define MAX 100009
int fun(int arr[], int n) {
/*if(n == 1) return 0LL;
if(n == 2) return abs(arr[n]-arr[n-1]);
return min(abs(arr[n]-arr[n-1]) + fun(arr, n-1), abs(arr[n]-arr[n-2]) + fun(arr,
n-2));*/
int dp[n + 1];
dp[1] = 0LL;
dp[2] = abs(arr[2] - arr[1]);
for (int i = 3; i <= n; i++) {
dp[i] = min(abs(arr[i] - arr[i - 1]) + dp[i - 1],
abs(arr[i] - arr[i - 2]) + dp[i - 2]);
}
return dp[n];
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int T = 1;
// cin >> T;
FOR1(i, T) {
// cout << "Case #" << i << ": \n";
int n;
cin >> n;
int a[n + 1];
FOR1(i, n) cin >> a[i];
cout << fun(a, n);
cout << '\n';
}
return 0;
}
| [
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 953,673 | 953,674 | u391763659 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i, h[100009], dp[100009];
cin >> n;
for (i = 1; i <= n; i++)
cin >> h[i];
dp[0] = dp[1] = 0;
for (i = 2; i <= n; i++)
dp[i] =
min(dp[i - 1] + abs(h[i] - h[i - 1]), dp[i - 2] + abs(h[i] - h[i - 2]));
cout << dp[n];
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i, h[100009], dp[100009];
cin >> n;
for (i = 1; i <= n; i++)
cin >> h[i];
dp[0] = INT_MAX;
dp[1] = 0;
for (i = 2; i <= n; i++)
dp[i] =
min(dp[i - 1] + abs(h[i] - h[i - 1]), dp[i - 2] + abs(h[i] - h[i - 2]));
cout << dp[n];
}
| [
"assignment.add"
] | 953,675 | 953,676 | u811723415 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, h[100009], dp[100009];
cin >> n;
for (i = 1; i <= n; i++)
cin >> h[i];
dp[0] = dp[1] = 0;
for (i = 2; i <= n; i++)
dp[i] =
min(dp[i - 1] + abs(h[i] - h[i - 1]), dp[i - 2] + abs(h[i] - h[i - 2]));
cout << dp[n];
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i, h[100009], dp[100009];
cin >> n;
for (i = 1; i <= n; i++)
cin >> h[i];
dp[0] = INT_MAX;
dp[1] = 0;
for (i = 2; i <= n; i++)
dp[i] =
min(dp[i - 1] + abs(h[i] - h[i - 1]), dp[i - 2] + abs(h[i] - h[i - 2]));
cout << dp[n];
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"assignment.add"
] | 953,677 | 953,676 | u811723415 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
ll dp[100005];
int main() {
memset(dp, -1, sizeof(dp));
ll n;
cin >> n;
ll arr[n];
for (ll i = 1; i <= n; i++)
cin >> arr[i];
dp[1] = arr[1];
dp[2] = abs(arr[1] - arr[2]);
for (int i = 3; i <= n; i++) {
dp[i] = min(dp[i - 1] + abs(arr[i] - arr[i - 1]),
dp[i - 2] + abs(arr[i] - arr[i - 2]));
}
cout << dp[n] << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
ll dp[100005];
int main() {
memset(dp, -1, sizeof(dp));
ll n;
cin >> n;
ll arr[n];
for (ll i = 1; i <= n; i++)
cin >> arr[i];
dp[1] = 0;
dp[2] = abs(arr[1] - arr[2]);
for (int i = 3; i <= n; i++) {
dp[i] = min(dp[i - 1] + abs(arr[i] - arr[i - 1]),
dp[i - 2] + abs(arr[i] - arr[i - 2]));
}
cout << dp[n] << endl;
} | [
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add"
] | 953,686 | 953,687 | u004051291 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int dp1[100005];
int least[100005];
int n;
int dp(int m) {
if (m == 2)
return abs(least[2] - least[0]);
if (m == 1)
return abs(least[1] - least[0]);
if (dp1[m])
return dp1[m];
return dp1[m] = min(abs(least[m] - least[m - 1]) + dp(m - 1),
abs(least[m] - least[m - 2]) + dp(m - 2));
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d", &least[i]);
dp1[i] = -1;
}
cout << dp(n - 1) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int dp1[100005];
int least[100005];
int n;
int dp(int m) {
if (m == 2)
return abs(least[2] - least[0]);
if (m == 1)
return abs(least[1] - least[0]);
if (dp1[m] > -1)
return dp1[m];
return dp1[m] = min(abs(least[m] - least[m - 1]) + dp(m - 1),
abs(least[m] - least[m - 2]) + dp(m - 2));
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d", &least[i]);
dp1[i] = -1;
}
cout << dp(n - 1) << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 953,693 | 953,694 | u240258562 | cpp |
p03160 | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <map>
#include <numeric>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define repd(i, a, b) for (ll i = (ll)(a); i < (ll)(b); i++)
#define repdm(i, a, b) for (ll i = (ll)(a); i > (ll)(b); i--)
const ll INF = 1LL << 60;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
ll N;
cin >> N;
ll h[N];
rep(i, N) cin >> h[i];
ll dp[N];
rep(i, N) dp[i] = INF;
dp[0] = 0;
repd(i, 0, N - 2) {
chmin(dp[i + 1], dp[i] + abs(h[i] - h[i + 1]));
chmin(dp[i + 2], dp[i] + abs(h[i] - h[i + 2]));
}
cout << dp[N - 1];
}
| #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <map>
#include <numeric>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define repd(i, a, b) for (ll i = (ll)(a); i < (ll)(b); i++)
#define repdm(i, a, b) for (ll i = (ll)(a); i > (ll)(b); i--)
const ll INF = 1LL << 60;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
ll N;
cin >> N;
ll h[N];
rep(i, N) cin >> h[i];
ll dp[N];
rep(i, N) dp[i] = INF;
dp[0] = 0;
repd(i, 0, N) {
chmin(dp[i + 1], dp[i] + abs(h[i] - h[i + 1]));
chmin(dp[i + 2], dp[i] + abs(h[i] - h[i + 2]));
}
cout << dp[N - 1];
}
| [
"expression.operation.binary.remove"
] | 953,708 | 953,709 | u879674287 | cpp |
p03160 | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <map>
#include <numeric>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define repd(i, a, b) for (ll i = (ll)(a); i < (ll)(b); i++)
#define repdm(i, a, b) for (ll i = (ll)(a); i > (ll)(b); i--)
const ll INF = 1LL << 60;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
ll N;
cin >> N;
ll h[N];
rep(i, N) cin >> h[i];
ll dp[N];
rep(i, N) dp[i] = INF;
dp[0] = 0;
repd(i, 1, N) {
chmin(dp[i], dp[i - 1] + abs(h[i] - dp[i - 1]));
if (i == 1)
continue;
chmin(dp[i], dp[i - 2] + abs(h[i] - dp[i - 2]));
}
cout << dp[N - 1];
}
| #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <map>
#include <numeric>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define repd(i, a, b) for (ll i = (ll)(a); i < (ll)(b); i++)
#define repdm(i, a, b) for (ll i = (ll)(a); i > (ll)(b); i--)
const ll INF = 1LL << 60;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
ll N;
cin >> N;
ll h[N];
rep(i, N) cin >> h[i];
ll dp[N];
rep(i, N) dp[i] = INF;
dp[0] = 0;
repd(i, 1, N) {
chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
if (i == 1)
continue;
chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
cout << dp[N - 1];
}
| [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 953,710 | 953,711 | u879674287 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> h(n);
for (int i = 0; i < n; i++) {
cin >> h[i];
}
// i番目に到達するために必要なコストの最小値をdp[i]とする。
int dp[10010];
// dpテーブルの初期化
dp[0] = 0;
dp[1] = 0;
dp[2] = h[1] - h[0];
for (int i = 2; i < n; i++) {
dp[i + 1] =
min(dp[i] + abs(h[i] - h[i - 1]), dp[i - 1] + abs(h[i] - h[i - 2]));
}
cout << dp[n] << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> h(n);
for (int i = 0; i < n; i++) {
cin >> h[i];
}
// i番目に到達するために必要なコストの最小値をdp[i]とする。
int dp[n];
// dpテーブルの初期化
dp[0] = 0;
dp[1] = 0;
dp[2] = abs(h[1] - h[0]);
for (int i = 2; i < n; i++) {
dp[i + 1] =
min(dp[i] + abs(h[i] - h[i - 1]), dp[i - 1] + abs(h[i] - h[i - 2]));
}
cout << dp[n] << endl;
}
| [
"identifier.replace.add",
"literal.replace.remove",
"variable_declaration.array_dimensions.change",
"call.add",
"call.arguments.change"
] | 953,715 | 953,713 | u882039496 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
int main() {
int n;
cin >> n;
vector<int> stones = vector<int>(n);
vector<int> dp = vector<int>(n, INF);
for (int i = 0; i < n; ++i)
cin >> stones[i];
dp[0] = 0;
for (int i = 0; i < n; ++i)
for (int j : {i + 1, i + 2})
if (j < n)
dp[i] = min(dp[i], dp[j] + abs(stones[i] - stones[j]));
cout << dp[n - 1] << "\n";
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
int main() {
int n;
cin >> n;
vector<int> stones = vector<int>(n);
vector<int> dp = vector<int>(n, INF);
for (int i = 0; i < n; ++i)
cin >> stones[i];
dp[0] = 0;
for (int i = 0; i < n; ++i)
for (int j : {i + 1, i + 2})
if (j < n)
dp[j] = min(dp[j], dp[i] + abs(stones[i] - stones[j]));
cout << dp[n - 1] << "\n";
return 0;
}
| [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 953,718 | 953,719 | u158312277 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
const long long INF = 1LL << 60;
long long dp[100010];
for (int i = 0; i < 100010; i++) {
dp[i] = 1LL;
}
dp[0] = 0;
int n;
cin >> n;
vector<int> height(n);
for (int i = 0; i < n; i++) {
cin >> height[i];
}
for (int i = 0; i < n; i++) {
chmin(dp[i + 1], dp[i] + abs(height[i + 1] - height[i]));
chmin(dp[i + 2], dp[i] + abs(height[i + 2] - height[i]));
}
cout << dp[n - 1] << endl;
}
| #include <bits/stdc++.h>
using namespace std;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
const long long INF = 1LL << 60;
long long dp[100010];
for (int i = 0; i < 100010; i++) {
dp[i] = INF;
}
dp[0] = 0;
int n;
cin >> n;
vector<int> height(n);
for (int i = 0; i < n; i++) {
cin >> height[i];
}
for (int i = 0; i < n; i++) {
chmin(dp[i + 1], dp[i] + abs(height[i + 1] - height[i]));
chmin(dp[i + 2], dp[i] + abs(height[i + 2] - height[i]));
}
cout << dp[n - 1] << endl;
}
| [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 953,724 | 953,725 | u011539601 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define lli long long
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
lli n, x;
cin >> n;
vector<lli> h;
for (lli i = 0; i < n; i++) {
cin >> x;
h.push_back(x);
}
vector<lli> dp(n, 999999);
dp[0] = 0;
for (lli i = 0; i < n; i++) {
for (lli j = i + 1; j <= i + 2; j++) {
if (j < n) {
dp[j] = min(dp[j], dp[j] + abs(h[i] - h[j]));
}
}
}
cout << dp[n - 1];
} | #include <bits/stdc++.h>
using namespace std;
#define lli long long
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
lli n, x;
cin >> n;
vector<lli> h;
for (lli i = 0; i < n; i++) {
cin >> x;
h.push_back(x);
}
vector<lli> dp(n, 999999999);
dp[0] = 0;
for (lli i = 0; i < n; i++) {
for (lli j = i + 1; j <= i + 2; j++) {
if (j < n) {
dp[j] = min(dp[j], dp[i] + abs(h[i] - h[j]));
}
}
}
cout << dp[n - 1];
} | [
"literal.number.change",
"call.arguments.change",
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 953,730 | 953,729 | u056755599 | cpp |
p03160 | #include <iostream>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int a[n + 1];
for (int i = 1; i <= n; i++)
scanf("%d", &a[i]);
int dp[n];
dp[1] = 0;
dp[2] = abs(a[2] - a[1]);
for (int i = 3; i <= n; i++) {
dp[i] = min(dp[i - 1] + abs(a[i] - a[i - 1]),
dp[i - 2] + abs(a[i - 1] - a[i - 2]));
}
printf("%d", dp[n]);
} | #include <iostream>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int a[n + 1];
for (int i = 1; i <= n; i++)
scanf("%d", &a[i]);
int dp[n];
dp[1] = 0;
dp[2] = abs(a[2] - a[1]);
for (int i = 3; i <= n; i++) {
dp[i] =
min(dp[i - 1] + abs(a[i] - a[i - 1]), dp[i - 2] + abs(a[i] - a[i - 2]));
}
printf("%d", dp[n]);
} | [
"expression.operation.binary.remove"
] | 953,731 | 953,732 | u051114039 | cpp |
p03160 | #include <cmath>
#include <iostream>
using namespace std;
int a[100005], dp[100005];
int main(int argc, char **argv) {
int n;
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i];
dp[1] = 0;
for (int i = 2; i <= n; i++) {
dp[i] = dp[i - 1] + abs(a[i] - a[i - 1]);
if (i > 1)
dp[i] = min(dp[i], dp[i - 2] + abs(a[i] - a[i - 2]));
}
cout << dp[n];
return 0;
} | #include <cmath>
#include <iostream>
using namespace std;
int a[100005], dp[100005];
int main(int argc, char **argv) {
int n;
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i];
dp[1] = 0;
for (int i = 2; i <= n; i++) {
dp[i] = dp[i - 1] + abs(a[i] - a[i - 1]);
if (i > 2)
dp[i] = min(dp[i], dp[i - 2] + abs(a[i] - a[i - 2]));
}
cout << dp[n];
return 0;
} | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 953,733 | 953,734 | u141633429 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.