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 <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define maxn 200005
#define int long long
int dp[maxn];
void solve() {
int n;
cin >> n;
int arr[n];
rep(i, n) { cin >> arr[i]; }
dp[0] = 0;
dp[1] = arr[1] - arr[0];
for (int 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];
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define maxn 200005
#define int long long
int dp[maxn];
void solve() {
int n;
cin >> n;
int arr[n];
rep(i, n) { cin >> arr[i]; }
dp[0] = 0;
dp[1] = abs(arr[1] - arr[0]);
for (int 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];
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| [
"call.add",
"call.arguments.change"
] | 956,073 | 956,074 | u829410922 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> dp(n + 2, 100005), h(n);
for (int i = 0; i < n; i++)
cin >> h[i];
dp[0] = 0;
for (int i = 0; i < n; i++) {
dp[i + 2] = min(dp[i + 2], dp[i] + abs(h[i + 2] - h[i]));
dp[i + 1] = min(dp[i + 1], dp[i] + abs(h[i] - h[i + 1]));
}
cout << dp[n - 1] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> dp(n + 2, 1e9), h(n);
for (int i = 0; i < n; i++)
cin >> h[i];
dp[0] = 0;
for (int i = 0; i < n; i++) {
dp[i + 2] = min(dp[i + 2], dp[i] + abs(h[i + 2] - h[i]));
dp[i + 1] = min(dp[i + 1], dp[i] + abs(h[i] - h[i + 1]));
}
cout << dp[n - 1] << endl;
return 0;
} | [
"literal.number.change",
"call.arguments.change"
] | 956,083 | 956,084 | u754651673 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int dp[200005];
int main() {
int n, a[200005], i, j;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i];
}
dp[0] = a[0];
dp[1] = abs(a[1] - a[0]);
for (i = 2; 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];
}
| #include <bits/stdc++.h>
using namespace std;
int dp[200005];
int main() {
int n, a[200005], i, j;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i];
}
dp[0] = 0;
dp[1] = abs(a[1] - a[0]);
for (i = 2; 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[i]<<' ';
}
cout << dp[n - 1];
}
| [] | 956,087 | 956,088 | u900937596 | cpp |
p03160 | //
// main.cpp
// Hello
//
// Created by 古園孔士 on 2019/05/18.
// Copyright © 2019 古園孔士. All rights reserved.
//
#include <bits/stdc++.h>
#define rep(i, a, n) for (int i = a; i < n; i++)
int n;
int H[100005];
int DP[100005];
using namespace std;
int main() {
cin >> n;
rep(i, 0, n) { cin >> H[i + 1]; }
H[0] = H[1];
DP[0] = 0;
DP[1] = H[1];
rep(i, 2, 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;
}
| #include <bits/stdc++.h>
#define rep(i, a, n) for (int i = a; i < n; i++)
int n;
int H[100005];
int DP[100005];
using namespace std;
int main() {
cin >> n;
rep(i, 0, n) { cin >> H[i + 1]; }
H[0] = H[1];
DP[0] = 0;
DP[1] = 0;
rep(i, 2, 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;
}
| [
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add"
] | 956,089 | 956,090 | u885523920 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
#define mp make_pair
const int maxn = 4e5 + 5;
const int MOD = 1e9 + 7;
#define mod(x) x % MOD
#define INF 0x3f3f3f3f
int dp[maxn];
int a[maxn];
int main() {
int n = 0;
while (~scanf("%d", &n)) {
for (int i = 1; i <= n; i++) {
a[i] = MOD;
}
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
}
dp[0] = 0;
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]));
}
/*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]));
}*/
printf("%d\n", dp[n]);
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
#define mp make_pair
const int maxn = 4e5 + 5;
const int MOD = 1e9 + 7;
#define mod(x) x % MOD
#define INF 0x3f3f3f3f
int dp[maxn];
int a[maxn];
int main() {
int n = 0;
while (~scanf("%d", &n)) {
for (int i = 1; i <= n; i++) {
a[i] = MOD;
}
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
}
dp[0] = 0;
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]));
}
/*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]));
}*/
printf("%d\n", dp[n]);
}
return 0;
} | [
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 956,091 | 956,092 | u985230013 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define pb push_back
#define mp make_pair
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++)
cin >> arr[i];
int dp[n] = {0};
dp[1] = abs(arr[0] - arr[1]);
for (int i = 0; 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];
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define pb push_back
#define mp make_pair
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++)
cin >> arr[i];
int dp[n] = {0};
dp[1] = abs(arr[0] - arr[1]);
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];
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change"
] | 956,095 | 956,096 | u506112954 | 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];
for (int i = 0; i < n; i++)
dp[i] = 10001;
dp[0] = 0;
for (int i = 0; i < n - 1; i++) {
dp[i + 1] = min(dp[i + 1], dp[i] + abs(h[i + 1] - h[i]));
if (i + 2 < n)
dp[i + 2] = min(dp[i + 2], dp[i] + abs(h[i + 2] - h[i]));
}
cout << dp[n - 1] << "\n";
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];
for (int i = 0; i < n; i++)
dp[i] = 1000000001;
dp[0] = 0;
for (int i = 0; i < n - 1; i++) {
dp[i + 1] = min(dp[i + 1], dp[i] + abs(h[i + 1] - h[i]));
if (i + 2 < n)
dp[i + 2] = min(dp[i + 2], dp[i] + abs(h[i + 2] - h[i]));
}
cout << dp[n - 1] << "\n";
return 0;
}
| [
"literal.number.change",
"assignment.value.change"
] | 956,102 | 956,103 | u599197778 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int h[n], cost[n], i;
for (i = 0; i < n; i++)
cin >> h[i];
cost[0] = 0;
cost[1] = abs(h[1] - h[0]);
if (n > 2) {
cost[2] = min(abs(h[2] - h[0]), cost[1] + abs(h[2] - h[1]));
for (i = 0; i < n; i++) {
cost[i] = min(cost[i - 1] + abs(h[i] - h[i - 1]),
cost[i - 2] + abs(h[i] - h[i - 2]));
}
}
cout << cost[n - 1];
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int h[n], cost[n], i;
for (i = 0; i < n; i++)
cin >> h[i];
cost[0] = 0;
cost[1] = abs(h[1] - h[0]);
if (n > 2) {
cost[2] = min(abs(h[2] - h[0]), cost[1] + abs(h[2] - h[1]));
for (i = 3; i < n; i++) {
cost[i] = min(cost[i - 1] + abs(h[i] - h[i - 1]),
cost[i - 2] + abs(h[i] - h[i - 2]));
}
}
cout << cost[n - 1];
} | [
"literal.number.change",
"assignment.value.change",
"control_flow.loop.for.initializer.change"
] | 956,104 | 956,105 | u392433498 | cpp |
p03160 | #pragma region template
#include <bits/stdc++.h>
using namespace std;
#pragma region random
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
template <typename T> T randint(T a, T b) {
return uniform_int_distribution<T>(a, b)(rng);
}
#pragma endregion
#pragma region debug
string to_string(string s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B> string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A> string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first)
res += ", ";
first = false;
res += to_string(x);
}
res += "}";
return res;
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#pragma endregion
#pragma endregion
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<int> dp(n), height(n);
for (int i = 0; i < n; i++)
cin >> height[i];
dp[0] = 0;
dp[1] = height[1] - height[0];
for (int i = 2; i < n; i++) {
dp[i] = min(dp[i - 2] + abs(height[i] - height[i - 2]),
dp[i - 1] + abs(height[i] - height[i - 1]));
}
// debug(dp);
cout << dp[n - 1];
return 0;
}
| #pragma region template
#include <bits/stdc++.h>
using namespace std;
#pragma region random
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
template <typename T> T randint(T a, T b) {
return uniform_int_distribution<T>(a, b)(rng);
}
#pragma endregion
#pragma region debug
string to_string(string s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B> string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A> string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first)
res += ", ";
first = false;
res += to_string(x);
}
res += "}";
return res;
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#pragma endregion
#pragma endregion
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<int> dp(n), height(n);
for (int i = 0; i < n; i++)
cin >> height[i];
dp[0] = 0;
dp[1] = abs(height[1] - height[0]);
for (int i = 2; i < n; i++) {
dp[i] = min(dp[i - 2] + abs(height[i] - height[i - 2]),
dp[i - 1] + abs(height[i] - height[i - 1]));
}
// debug(dp);
cout << dp[n - 1];
return 0;
}
| [
"call.add",
"call.arguments.change"
] | 956,106 | 956,107 | u670109291 | cpp |
p03160 | #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <vector>
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define EACH(x, a) for (auto &(x) : (a))
#define ALL(obj) (obj).begin(), (obj).end()
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl;
#define CO(x) cout << (x) << endl;
#define COSP(x) cout << (x) << " ";
#define DICIMAL(x) fixed << setprecision(x)
using namespace std;
using ll = long long;
using vi = vector<int>;
const int INF = 1e9;
const ll LINF = 1e18;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vi h(N);
REP(i, N) cin >> h[i];
vi dp(N);
dp[0] = 0;
dp[1] = h[0] + abs(h[0] - h[1]);
FOR(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] << endl;
return 0;
}
| #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <vector>
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define EACH(x, a) for (auto &(x) : (a))
#define ALL(obj) (obj).begin(), (obj).end()
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl;
#define CO(x) cout << (x) << endl;
#define COSP(x) cout << (x) << " ";
#define DICIMAL(x) fixed << setprecision(x)
using namespace std;
using ll = long long;
using vi = vector<int>;
const int INF = 1e9;
const ll LINF = 1e18;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vi h(N);
REP(i, N) cin >> h[i];
vi dp(N);
dp[0] = 0;
dp[1] = abs(h[0] - h[1]);
FOR(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] << endl;
return 0;
}
| [
"expression.operation.binary.remove"
] | 956,115 | 956,116 | u625729943 | cpp |
p03160 | #include <iostream>
using namespace std;
int main() {
int n, i, j;
int h[1000000];
int dp[1000000];
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &h[i]);
}
dp[1] = abs(h[1] - h[0]);
for (i = 1; i <= n; i++) {
dp[i] =
min(dp[i - 1] + abs(h[i] - h[i - 1]), dp[i - 2] + abs(h[i] - h[i - 2]));
}
printf("%d\n", dp[n - 1]);
} | #include <iostream>
using namespace std;
int main() {
int n, i, j;
int h[1000000];
int dp[1000000];
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &h[i]);
}
dp[1] = abs(h[1] - h[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]));
}
printf("%d\n", dp[n - 1]);
} | [
"literal.number.change",
"assignment.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 956,122 | 956,123 | u083251423 | cpp |
p03160 | #include <iostream>
using namespace std;
int main() {
int n, i, j;
int h[100001];
int dp[100001];
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &h[i]);
}
dp[1] = abs(h[1] - h[0]);
for (i = 1; i <= n; i++) {
dp[i] =
min(dp[i - 1] + abs(h[i] - h[i - 1]), dp[i - 2] + abs(h[i] - h[i - 2]));
}
printf("%d\n", dp[n - 1]);
} | #include <iostream>
using namespace std;
int main() {
int n, i, j;
int h[1000000];
int dp[1000000];
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &h[i]);
}
dp[1] = abs(h[1] - h[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]));
}
printf("%d\n", dp[n - 1]);
} | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"assignment.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 956,124 | 956,123 | u083251423 | cpp |
p03160 | #include <cstdlib>
#include <iostream>
using namespace std;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const long long INF = 1LL << 60;
int main() {
int N;
cin >> N;
int h[N];
long long dp[100010];
for (int i = 0; i < 100010; i++)
dp[i] = INF;
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++) {
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 - 1] << endl;
}
| #include <cstdlib>
#include <iostream>
using namespace std;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const long long INF = 1LL << 60;
int main() {
int N;
cin >> N;
int h[N];
long long dp[100010];
for (int i = 0; i < 100010; i++)
dp[i] = INF;
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++) {
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 - 1] << endl;
}
| [
"call.add",
"call.arguments.change"
] | 956,131 | 956,132 | u353789691 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define PI 3.14159265359
#define fore(i, l, r) for (int i = int(l); i < int(r); ++i)
#define pb(a) push_back(a)
//////////// Solution /////////////////////////////////
const int MAXN = 1e5 + 1;
void solve() {
int h[MAXN];
ll dp[MAXN];
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> h[i];
}
dp[0] = 0;
dp[1] = 0;
for (int i = 2; i <= n; ++i) {
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]));
}
}
cout << dp[n] << '\n';
}
/////////// End Solution ///////////////////////////////////////
//////// Initialization ////////////////////////////////////
int main() {
#ifndef ONLINE_JUDGE
FILE *FIN = freopen("/home/danil/prog/input.txt", "r", stdin);
clock_t time_start = clock();
#endif
ios::sync_with_stdio(false);
cin.tie(NULL);
solve();
#ifndef ONLINE_JUDGE
fclose(FIN);
cerr << "\x1b[031m\n-----------------\nTime="
<< (ll)((double)(clock() - time_start) / CLOCKS_PER_SEC * 1000)
<< "ms\n\x1b[0m";
#endif
return 0;
}
//////// End Initialization /////////////////////////////////////// | #include <bits/stdc++.h>
using namespace std;
#define ONLINE_JUDGE
#define ll long long
#define PI 3.14159265359
#define fore(i, l, r) for (int i = int(l); i < int(r); ++i)
#define pb(a) push_back(a)
//////////// Solution /////////////////////////////////
const int MAXN = 1e5 + 1;
void solve() {
int h[MAXN];
ll dp[MAXN];
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> h[i];
}
dp[0] = 0;
dp[1] = 0;
for (int i = 2; i <= n; ++i) {
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]));
}
}
cout << dp[n] << '\n';
}
/////////// End Solution ///////////////////////////////////////
//////// Initialization ////////////////////////////////////
int main() {
#ifndef ONLINE_JUDGE
FILE *FIN = freopen("/home/danil/prog/input.txt", "r", stdin);
clock_t time_start = clock();
#endif
ios::sync_with_stdio(false);
cin.tie(NULL);
solve();
#ifndef ONLINE_JUDGE
fclose(FIN);
cerr << "\x1b[031m\n-----------------\nTime="
<< (ll)((double)(clock() - time_start) / CLOCKS_PER_SEC * 1000)
<< "ms\n\x1b[0m";
#endif
return 0;
}
//////// End Initialization /////////////////////////////////////// | [] | 956,133 | 956,134 | u361383723 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
long long n, a[100010], kq[100010], x;
main() {
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i];
kq[2] = abs(a[2] - a[1]);
kq[3] = min(abs(a[3] - a[1]), kq[2] + abs(a[2] - a[1]));
for (int i = 4; i <= n; i++)
kq[i] =
min(kq[i - 1] + abs(a[i] - a[i - 1]), kq[i - 2] + abs(a[i] - a[i - 2]));
cout << kq[n];
}
| #include <bits/stdc++.h>
using namespace std;
long long n, a[100010], kq[100010], x;
main() {
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i];
kq[2] = abs(a[2] - a[1]);
kq[3] = min(abs(a[3] - a[1]), kq[2] + abs(a[3] - a[2]));
for (int i = 4; i <= n; i++)
kq[i] =
min(kq[i - 1] + abs(a[i] - a[i - 1]), kq[i - 2] + abs(a[i] - a[i - 2]));
cout << kq[n];
}
| [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 956,137 | 956,138 | u464042361 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int n, a[100010], kq[100010], x;
main() {
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i];
kq[2] = abs(a[2] - a[1]);
kq[3] = min(abs(a[3] - a[1]), kq[2] + abs(a[2] - a[1]));
for (int i = 4; i <= n; i++)
kq[i] =
min(kq[i - 1] + abs(a[i] - a[i - 1]), kq[i - 2] + abs(a[i] - a[i - 2]));
cout << kq[n];
}
| #include <bits/stdc++.h>
using namespace std;
long long n, a[100010], kq[100010], x;
main() {
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i];
kq[2] = abs(a[2] - a[1]);
kq[3] = min(abs(a[3] - a[1]), kq[2] + abs(a[3] - a[2]));
for (int i = 4; i <= n; i++)
kq[i] =
min(kq[i - 1] + abs(a[i] - a[i - 1]), kq[i - 2] + abs(a[i] - a[i - 2]));
cout << kq[n];
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 956,139 | 956,138 | u464042361 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
int main() {
// freopen("FORM.inp", "r", stdin);
// freopen("FORM.out", "w", stdout);
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
long long a[n + 1], dp[n + 1];
for (int i = 1; i <= n; i++)
cin >> a[i];
dp[2] = abs(a[1] - a[2]);
dp[3] = min(abs(a[1] - a[3]), abs(a[2] - a[3]));
for (int i = 4; 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];
}
| #include <bits/stdc++.h>
using namespace std;
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
int main() {
// freopen("FORM.inp", "r", stdin);
// freopen("FORM.out", "w", stdout);
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
long long a[n + 1], dp[n + 1];
for (int i = 1; i <= n; i++)
cin >> a[i];
dp[2] = abs(a[1] - a[2]);
dp[3] = min(abs(a[1] - a[3]), abs(a[2] - a[3]) + dp[2]);
for (int i = 4; 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];
}
| [
"assignment.change"
] | 956,140 | 956,141 | u162854028 | cpp |
p03160 |
#include <bits/stdc++.h>
#define maxn 1e9 + 5
#define ll long long int
using namespace std;
int main() {
ll n;
cin >> n;
vector<ll> h(n), dp(n + 1, maxn);
for (int i = 0; i < n; i++)
cin >> h[i];
dp[0] = 0;
for (int i = 1; i <= n; i++) {
for (auto j : {i - 1, i - 2}) {
if (j >= 0) {
dp[i] = min(dp[i], dp[j]) +
abs(h[i] - h[j]); // here we take the minimum of the two moves
// from the past and adding the their diffrence
// from current position.
}
}
}
cout << dp[n - 1] << "\n";
return 0;
} |
#include <bits/stdc++.h>
#define maxn 1e9 + 5
#define ll long long int
using namespace std;
int main() {
ll n;
cin >> n;
vector<ll> h(n), dp(n + 1, maxn);
for (int i = 0; i < n; i++)
cin >> h[i];
dp[0] = 0;
for (int i = 1; i < n; i++) {
for (auto j : {i - 1, i - 2}) {
if (j >= 0) {
dp[i] = min(
dp[i],
dp[j] +
abs(h[i] - h[j])); // this means we take min of current position
// and (position from past+distance/height to
// reach current position) and then check for
// different moves for min value
}
}
}
cout << dp[n - 1] << "\n";
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"call.arguments.change"
] | 956,152 | 956,153 | u677572222 | cpp |
p03160 |
#include <bits/stdc++.h>
#define maxn 100000
#define ll long long int
using namespace std;
int main() {
ll n;
cin >> n;
vector<ll> h(n), dp(n + 1, maxn);
for (int i = 0; i < n; i++)
cin >> h[i];
dp[0] = 0;
for (int i = 1; i <= n; i++) {
for (auto j : {i - 1, i - 2}) {
if (j >= 0) {
dp[i] = min(
dp[i],
dp[j] + abs(h[i] - h[j])); // here we take the minimum of the two
// moves from the past and adding the
// their diffrence from current position.
}
}
}
cout << dp[n - 1] << "\n";
return 0;
} |
#include <bits/stdc++.h>
#define maxn 1e9 + 5
#define ll long long int
using namespace std;
int main() {
ll n;
cin >> n;
vector<ll> h(n), dp(n + 1, maxn);
for (int i = 0; i < n; i++)
cin >> h[i];
dp[0] = 0;
for (int i = 1; i < n; i++) {
for (auto j : {i - 1, i - 2}) {
if (j >= 0) {
dp[i] = min(
dp[i],
dp[j] +
abs(h[i] - h[j])); // this means we take min of current position
// and (position from past+distance/height to
// reach current position) and then check for
// different moves for min value
}
}
}
cout << dp[n - 1] << "\n";
return 0;
} | [
"preprocessor.define.value.change",
"literal.float.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 956,154 | 956,153 | u677572222 | cpp |
p03160 |
#include <bits/stdc++.h>
#define maxn 100000
#define ll long long int
using namespace std;
int main() {
ll n;
cin >> n;
vector<ll> h(n), dp(n + 1, maxn);
for (int i = 0; i < n; i++)
cin >> h[i];
dp[0] = 0;
for (int i = 1; i <= n; i++) {
for (auto j : {i - 1, i - 2}) {
if (j >= 0) {
dp[i] = min(
dp[i],
dp[j] + abs(h[i] - h[j])); // here we take the minimum of the two
// moves from the past and adding the
// their diffrence from current position.
}
}
}
cout << dp[n - 1] << "\n";
return 0;
} |
#include <bits/stdc++.h>
#define maxn 1e9 + 5
#define ll long long int
using namespace std;
int main() {
ll n;
cin >> n;
vector<ll> h(n), dp(n + 1, maxn);
for (int i = 0; i < n; i++)
cin >> h[i];
dp[0] = 0;
for (int i = 1; i <= n; i++) {
for (auto j : {i - 1, i - 2}) {
if (j >= 0) {
dp[i] = min(
dp[i],
dp[j] + abs(h[i] - h[j])); // here we take the minimum of the two
// moves from the past and adding the
// their diffrence from current position.
}
}
}
cout << dp[n - 1] << "\n";
return 0;
} | [
"preprocessor.define.value.change",
"literal.float.change"
] | 956,154 | 956,155 | u677572222 | cpp |
p03160 | #include <bits/stdc++.h>
#define ll long long
#define rep(i, a, b) for (i = a; i < b; i++)
#define pb push_back
#define all(v) v.begin(), v.end()
#define F first
#define S second
#define CLR(a) memset((a), 0, sizeof(a))
#define mp make_pair
#define hell 1000000007
using namespace std;
// int g[105][105];
// vector < int > wt(100004);
// vector < int > a;
// vector < int > v(30500);
// int cst[102][100005];
// int ansr[100005];
// ll int sum,x=0,c=0,n,m,flag=0,a1,a2,flag1=0,flag2=0;
// vector < vector < int > > adj(5000, vector < int > (5000));
// int dp[1000006];
// int level[500];
void solve() {
long long int i, j = 0, r = 200, p, q, k = 0, ans = 0, d, h, flag = 0, n,
m = 0, a, b, id, c, h1, h2, a1, b1;
cin >> n;
vector<int> v(n), dp(n, 100000);
rep(i, 0, n) { cin >> v[i]; }
dp[0] = 0;
dp[1] = abs(v[1] - v[0]);
rep(i, 2, n) {
dp[i] = min(dp[i], min(dp[i - 1] + abs(v[i - 1] - v[i]),
dp[i - 2] + abs(v[i - 2] - v[i])));
}
cout << dp[n - 1];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
// cin>>t;
while (t--)
solve();
}
/*
void bfs( int i , int j)
{
vis[i][j]= true;
queue < int > que;
que.push(k);
while(!que.empty())
{
int x= que.front();
que.pop();
for ( int i=1;i<=n;i++)
{
if((!g[1][n] and g[x][i] ) or (g[1][n] and ! g[x][i]))
{
if(!vis[i])
{
que.push(i);
level[i]=level[x]+1;
vis[i]= true;
}
}
}
}
}
ll int por(ll int a,ll int b)
{
ll int k=1;
while(b>0)
{
if(b%2) k=k*a,k%=hell;
b/=2;
a*=a; a%=hell;
}
return k;
} */
| #include <bits/stdc++.h>
#define ll long long
#define rep(i, a, b) for (i = a; i < b; i++)
#define pb push_back
#define all(v) v.begin(), v.end()
#define F first
#define S second
#define CLR(a) memset((a), 0, sizeof(a))
#define mp make_pair
#define hell 1000000007
using namespace std;
// int g[105][105];
// vector < int > wt(100004);
// vector < int > a;
// vector < int > v(30500);
// int cst[102][100005];
// int ansr[100005];
// ll int sum,x=0,c=0,n,m,flag=0,a1,a2,flag1=0,flag2=0;
// vector < vector < int > > adj(5000, vector < int > (5000));
// int dp[1000006];
// int level[500];
void solve() {
int i, j = 0, r = 200, p, q, k = 0, ans = 0, d, h, flag = 0, n, m = 0, a, b,
id, c, h1, h2, a1, b1;
cin >> n;
vector<int> v(n), dp(n, hell);
rep(i, 0, n) { cin >> v[i]; }
dp[0] = 0;
dp[1] = abs(v[1] - v[0]);
rep(i, 2, n) {
dp[i] = min(dp[i], min(dp[i - 1] + abs(v[i - 1] - v[i]),
dp[i - 2] + abs(v[i - 2] - v[i])));
}
cout << dp[n - 1];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
// cin>>t;
while (t--)
solve();
}
/*
void bfs( int i , int j)
{
vis[i][j]= true;
queue < int > que;
que.push(k);
while(!que.empty())
{
int x= que.front();
que.pop();
for ( int i=1;i<=n;i++)
{
if((!g[1][n] and g[x][i] ) or (g[1][n] and ! g[x][i]))
{
if(!vis[i])
{
que.push(i);
level[i]=level[x]+1;
vis[i]= true;
}
}
}
}
}
ll int por(ll int a,ll int b)
{
ll int k=1;
while(b>0)
{
if(b%2) k=k*a,k%=hell;
b/=2;
a*=a; a%=hell;
}
return k;
} */
| [
"call.arguments.change"
] | 956,169 | 956,168 | u216069198 | cpp |
p03160 | #include <bits/stdc++.h>
#define ll long long
#define rep(i, a, b) for (i = a; i < b; i++)
#define pb push_back
#define all(v) v.begin(), v.end()
#define F first
#define S second
#define CLR(a) memset((a), 0, sizeof(a))
#define mp make_pair
#define hell 1000000007
using namespace std;
// int g[105][105];
// vector < int > wt(100004);
// vector < int > a;
// vector < int > v(30500);
// int cst[102][100005];
// int ansr[100005];
// ll int sum,x=0,c=0,n,m,flag=0,a1,a2,flag1=0,flag2=0;
// vector < vector < int > > adj(5000, vector < int > (5000));
// int dp[1000006];
// int level[500];
void solve() {
long long int i, j = 0, r = 200, p, q, k = 0, ans = 0, d, h, flag = 0, n,
m = 0, a, b, id, c, h1, h2, a1, b1;
cin >> n;
vector<int> v(n), dp(n, 100000);
rep(i, 0, n) { cin >> v[i]; }
dp[0] = 0;
dp[1] = abs(v[1] - v[0]);
rep(i, 2, n) {
dp[i] = min(dp[i], min(dp[i - 1] + abs(v[i - 1] - v[i]),
dp[i - 2] + abs(v[i - 2] - v[i])));
}
cout << dp[n - 1];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
// cin>>t;
while (t--)
solve();
}
/*
void bfs( int i , int j)
{
vis[i][j]= true;
queue < int > que;
que.push(k);
while(!que.empty())
{
int x= que.front();
que.pop();
for ( int i=1;i<=n;i++)
{
if((!g[1][n] and g[x][i] ) or (g[1][n] and ! g[x][i]))
{
if(!vis[i])
{
que.push(i);
level[i]=level[x]+1;
vis[i]= true;
}
}
}
}
}
ll int por(ll int a,ll int b)
{
ll int k=1;
while(b>0)
{
if(b%2) k=k*a,k%=hell;
b/=2;
a*=a; a%=hell;
}
return k;
} */
| #include <bits/stdc++.h>
#define ll long long
#define rep(i, a, b) for (i = a; i < b; i++)
#define pb push_back
#define all(v) v.begin(), v.end()
#define F first
#define S second
#define CLR(a) memset((a), 0, sizeof(a))
#define mp make_pair
#define hell 1000000007
using namespace std;
// int g[105][105];
// vector < int > wt(100004);
// vector < int > a;
// vector < int > v(30500);
// int cst[102][100005];
// int ansr[100005];
// ll int sum,x=0,c=0,n,m,flag=0,a1,a2,flag1=0,flag2=0;
// vector < vector < int > > adj(5000, vector < int > (5000));
// int dp[1000006];
// int level[500];
void solve() {
long long int i, j = 0, r = 200, p, q, k = 0, ans = 0, d, h, flag = 0, n,
m = 0, a, b, id, c, h1, h2, a1, b1;
cin >> n;
vector<ll int> v(n), dp(n, hell);
rep(i, 0, n) { cin >> v[i]; }
dp[0] = 0;
dp[1] = abs(v[1] - v[0]);
rep(i, 2, n) {
dp[i] = min(dp[i], min(dp[i - 1] + abs(v[i - 1] - v[i]),
dp[i - 2] + abs(v[i - 2] - v[i])));
}
cout << dp[n - 1];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
// cin>>t;
while (t--)
solve();
}
/*
void bfs( int i , int j)
{
vis[i][j]= true;
queue < int > que;
que.push(k);
while(!que.empty())
{
int x= que.front();
que.pop();
for ( int i=1;i<=n;i++)
{
if((!g[1][n] and g[x][i] ) or (g[1][n] and ! g[x][i]))
{
if(!vis[i])
{
que.push(i);
level[i]=level[x]+1;
vis[i]= true;
}
}
}
}
}
ll int por(ll int a,ll int b)
{
ll int k=1;
while(b>0)
{
if(b%2) k=k*a,k%=hell;
b/=2;
a*=a; a%=hell;
}
return k;
} */
| [
"call.arguments.change"
] | 956,169 | 956,170 | u216069198 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define pb emplace_back
#define f(i, n) for (int i = 1; i <= n; i++)
#define F first
#define S second
#define fast ios::sync_with_stdio(false), cin.tie(0);
const int N = 1e5 + 5;
int n, a[N], dp[N];
int32_t main() {
fast;
cin >> n;
f(i, n) cin >> a[i];
dp[1] = 0;
dp[2] = abs(a[2] - a[1]);
for (int i = 2; 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];
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
#define pb emplace_back
#define f(i, n) for (int i = 1; i <= n; i++)
#define F first
#define S second
#define fast ios::sync_with_stdio(false), cin.tie(0);
const int N = 1e5 + 5;
int n, a[N], dp[N];
int32_t main() {
fast;
cin >> n;
f(i, n) cin >> a[i];
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];
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 956,174 | 956,175 | u670919462 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
const long long int INF = 1 << 20;
int dp[100010];
int h[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 = 0; i < n; i++) {
dp[i + 1] = min(dp[i + 1], dp[i] + abs(h[i + 1] - h[i]));
dp[i + 2] = min(dp[i + 2], dp[i] + abs(h[i + 2] - h[i]));
}
cout << dp[n - 1] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 30;
int dp[100010];
int h[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 = 0; i < n; i++) {
dp[i + 1] = min(dp[i + 1], dp[i] + abs(h[i + 1] - h[i]));
dp[i + 2] = min(dp[i + 2], dp[i] + abs(h[i + 2] - h[i]));
}
cout << dp[n - 1] << endl;
return 0;
}
| [
"literal.number.change",
"expression.operation.binary.change"
] | 956,180 | 956,181 | u055447809 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
const long long int INF = 1 << 20;
int dp[100010];
int h[100010];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++)
cin >> h[i];
for (int i = 1; i < n; i++)
dp[i] = INF;
dp[0] = 0;
for (int i = 0; i < n; i++) {
dp[i + 1] = min(dp[i + 1], dp[i] + abs(h[i + 1] - h[i]));
dp[i + 2] = min(dp[i + 2], dp[i] + abs(h[i + 2] - h[i]));
}
cout << dp[n - 1] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 30;
int dp[100010];
int h[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 = 0; i < n; i++) {
dp[i + 1] = min(dp[i + 1], dp[i] + abs(h[i + 1] - h[i]));
dp[i + 2] = min(dp[i + 2], dp[i] + abs(h[i + 2] - h[i]));
}
cout << dp[n - 1] << endl;
return 0;
}
| [
"literal.number.change",
"expression.operation.binary.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change"
] | 956,182 | 956,181 | u055447809 | cpp |
p03160 | /*author* Priyanshu Shrivastav (from IIT Palakkad) *
* *_ __ ___ _ ______ ___ _ ____ ___ ___| |_ *
* | '_ ` _ \| '__/ __/ _ \| '_ \ \ / / |/ __| __| *
* | | | | | | | | (_| (_) | | | \ V /| | (__| |_ *
* |_| |_| |_|_|(_)___\___/|_| |_|\_/ |_|\___|\__| *
When I wrote this, only God and I understood what I was doing
** * * * * * * * Now, only God knows * * * * * * */
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define IOS \
ios_base::sync_with_stdio(false); \
cin.tie(nullptr)
#define PREC \
cout.precision(10); \
cout << fixed
#define bg(x) " [ " << #x << " : " << (x) << " ] "
#define x first
#define y second
using ll = long long;
using ff = long double;
using pii = pair<int, int>;
#define debug(args...) \
{ \
/* WARNING : do NOT compile this debug func calls with following flags: // \
* // -D_GLIBCXX_DEBUG -D_GLIBCXX_DEBUG_PEDANTIC -D_FORTIFY_SOURCE=2*/ \
string _s = #args; \
replace(_s.begin(), _s.end(), ',', ' '); \
stringstream _ss(_s); \
istream_iterator<string> _it(_ss); \
err(_it, args); \
}
void err(istream_iterator<string> it) {
it->empty();
cerr << " (Line : " << __LINE__ << ")" << '\n';
}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << fixed << setprecision(15) << " [ " << *it << " : " << a << " ] "
<< ' ';
err(++it, args...);
}
const int N = (int)1e5 + 10;
const ll inf = (ll)1e18;
int h[N];
ll dp[N];
int n;
void solve() {
for (int i = 1; i <= n; ++i)
dp[i] = inf;
dp[1] = 0;
for (int i = 2; i <= n; ++i) {
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 - 1]));
}
cout << dp[n] << '\n';
}
signed main() {
IOS;
PREC;
cin >> n;
for (int i = 1; i <= n; ++i)
cin >> h[i];
solve();
return EXIT_SUCCESS;
}
| /*author* Priyanshu Shrivastav (from IIT Palakkad) *
* *_ __ ___ _ ______ ___ _ ____ ___ ___| |_ *
* | '_ ` _ \| '__/ __/ _ \| '_ \ \ / / |/ __| __| *
* | | | | | | | | (_| (_) | | | \ V /| | (__| |_ *
* |_| |_| |_|_|(_)___\___/|_| |_|\_/ |_|\___|\__| *
When I wrote this, only God and I understood what I was doing
** * * * * * * * Now, only God knows * * * * * * */
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define IOS \
ios_base::sync_with_stdio(false); \
cin.tie(nullptr)
#define PREC \
cout.precision(10); \
cout << fixed
#define bg(x) " [ " << #x << " : " << (x) << " ] "
#define x first
#define y second
using ll = long long;
using ff = long double;
using pii = pair<int, int>;
#define debug(args...) \
{ \
/* WARNING : do NOT compile this debug func calls with following flags: // \
* // -D_GLIBCXX_DEBUG -D_GLIBCXX_DEBUG_PEDANTIC -D_FORTIFY_SOURCE=2*/ \
string _s = #args; \
replace(_s.begin(), _s.end(), ',', ' '); \
stringstream _ss(_s); \
istream_iterator<string> _it(_ss); \
err(_it, args); \
}
void err(istream_iterator<string> it) {
it->empty();
cerr << " (Line : " << __LINE__ << ")" << '\n';
}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << fixed << setprecision(15) << " [ " << *it << " : " << a << " ] "
<< ' ';
err(++it, args...);
}
const int N = (int)1e5 + 10;
const ll inf = (ll)1e18;
int h[N];
ll dp[N];
int n;
void solve() {
for (int i = 1; i <= n; ++i)
dp[i] = inf;
dp[1] = 0;
for (int i = 2; i <= n; ++i) {
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]));
}
cout << dp[n] << '\n';
}
signed main() {
IOS;
PREC;
cin >> n;
for (int i = 1; i <= n; ++i)
cin >> h[i];
solve();
return EXIT_SUCCESS;
}
| [
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 956,185 | 956,186 | u847902088 | cpp |
p03160 | #include <cmath>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
const ll INF = 100000000000;
int main() {
ll n;
cin >> n;
vector<ll> flog(n), dp(n + 2);
for (ll i = 0; i < n; ++i)
cin >> flog[i];
for (ll i = 0; i < n; ++i)
dp[i] = INF;
auto a = [](ll a, ll b) { return (a < b) ? a : b; };
dp[0] = 0;
for (ll i = 0; i < n - 1; ++i) {
dp[i + 1] = a(dp[i + 1], dp[i] + abs(flog[i + 1] - flog[i]));
dp[i + 2] = a(dp[i + 2], dp[i] + abs(flog[i + 2] - flog[i]));
}
cout << dp[n - 2] << endl;
return 0;
} | #include <cmath>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
const ll INF = 100000000000;
int main() {
ll n;
cin >> n;
vector<ll> flog(n), dp(n + 2);
for (ll i = 0; i < n; ++i)
cin >> flog[i];
for (ll i = 0; i < n; ++i)
dp[i] = INF;
auto a = [](ll a, ll b) { return (a < b) ? a : b; };
dp[0] = 0;
for (ll i = 0; i < n - 1; ++i) {
dp[i + 1] = a(dp[i + 1], dp[i] + abs(flog[i + 1] - flog[i]));
dp[i + 2] = a(dp[i + 2], dp[i] + abs(flog[i + 2] - flog[i]));
}
cout << dp[n - 1] << endl;
return 0;
} | [
"literal.number.change",
"variable_access.subscript.index.change",
"io.output.change"
] | 956,196 | 956,197 | u207460172 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, s, n) for (int(i) = (s); (i) < (n); (i)++)
int N, H[101010], dp[101010];
float inf = std::numeric_limits<float>::infinity();
// typedef long long ll; const int inf = INT_MAX / 2; const ll infl = 1LL << 60;
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
//---------------------------------------------------------------------------------------------------
int main() {
cin >> N;
rep(i, 0, N) cin >> H[i];
rep(i, 0, N) dp[i] = 1000000;
dp[0] = 0;
rep(i, 0, N) {
// dp[i + 1] = min(dp[i + 1], dp[i] + abs(H[i] - H[i + 1]));
// dp[i + 2] = min(dp[i + 2], dp[i] + abs(H[i] - H[i + 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[i+1] << " ";
}
cout << dp[N - 1] << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, s, n) for (int(i) = (s); (i) < (n); (i)++)
int N, H[101010], dp[101010];
float inf = std::numeric_limits<float>::infinity();
// typedef long long ll; const int inf = INT_MAX / 2; const ll infl = 1LL << 60;
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
//---------------------------------------------------------------------------------------------------
int main() {
cin >> N;
rep(i, 0, N) cin >> H[i];
rep(i, 0, N) dp[i] = 1000000000;
dp[0] = 0;
rep(i, 0, N) {
// dp[i + 1] = min(dp[i + 1], dp[i] + abs(H[i] - H[i + 1]));
// dp[i + 2] = min(dp[i + 2], dp[i] + abs(H[i] - H[i + 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[i+1] << " ";
}
cout << dp[N - 1] << endl;
} | [
"literal.number.change",
"assignment.value.change"
] | 956,198 | 956,199 | u792521295 | cpp |
p03160 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
const ll inf = 1e9 + 10;
const ll maxn = 1e5 + 163;
const ll alf = 26;
const ll dlm = 1e9 + 7;
const ll del = 10979;
const int eps = 1e-7;
const int maxq = 3e3 + 132;
int n;
int h[maxn];
ll dp[maxn];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++)
cin >> h[i];
dp[1] = 0;
dp[2] = abs(h[2] - h[1]);
for (int 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];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
const ll inf = 1e9 + 10;
const ll maxn = 1e5 + 163;
const ll alf = 26;
const ll dlm = 1e9 + 7;
const ll del = 10979;
const int eps = 1e-7;
const int maxq = 3e3 + 132;
int n;
int h[maxn];
ll dp[maxn];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++)
cin >> h[i];
dp[1] = 0;
dp[2] = abs(h[2] - h[1]);
for (int 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];
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 956,214 | 956,215 | u816037469 | cpp |
p03160 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
const ll inf = 1e9 + 10;
const ll maxn = 1e5 + 163;
const ll alf = 26;
const ll dlm = 1e9 + 7;
const ll del = 10979;
const int eps = 1e-7;
const int maxq = 3e3 + 132;
int n;
int h[maxn];
int dp[maxn];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++)
cin >> h[i];
dp[1] = 0;
dp[2] = abs(h[2] - h[1]);
for (int 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];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
const ll inf = 1e9 + 10;
const ll maxn = 1e5 + 163;
const ll alf = 26;
const ll dlm = 1e9 + 7;
const ll del = 10979;
const int eps = 1e-7;
const int maxq = 3e3 + 132;
int n;
int h[maxn];
ll dp[maxn];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++)
cin >> h[i];
dp[1] = 0;
dp[2] = abs(h[2] - h[1]);
for (int 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];
return 0;
}
| [
"variable_declaration.type.change",
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 956,216 | 956,215 | u816037469 | cpp |
p03160 | #include <iostream>
using namespace std;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const long long INF = 1LL;
int main() {
/* 入力 */
int n;
cin >> n;
long long h[100010];
for (int i = 0; i < n; ++i)
cin >> h[i];
/* DPテーブル */
long long dp[100010];
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]));
}
cout << dp[n - 1] << endl;
return 0;
} | #include <iostream>
using namespace std;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const long long INF = 1LL << 60;
int main() {
/* 入力 */
int n;
cin >> n;
long long h[100010];
for (int i = 0; i < n; ++i)
cin >> h[i];
/* DPテーブル */
long long dp[100010];
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]));
}
cout << dp[n - 1] << endl;
return 0;
} | [
"assignment.change"
] | 956,223 | 956,224 | u953753178 | cpp |
p03160 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
typedef long long LL;
int int_vector_find(std::vector<int> vec, int num) {
auto itr = std::find(vec.begin(), vec.end(), num);
int index = std::distance(vec.begin(), itr);
if (index != vec.size()) {
return 1;
} else {
return 0;
}
}
int n;
LL h[100010], dp[100010];
int main() {
std::cin >> n;
for (int i = 1; i <= n; ++i) {
std::cin >> h[i];
dp[i] = 1000000000;
}
dp[1] = 0;
for (int i = 2; i <= n; ++i) {
if (i == 2) {
dp[i] = dp[i - 1] + std::abs(h[i - 1] - h[i]);
}
dp[i] = std::min(dp[i - 1] + std::abs(h[i - 1] - h[i]),
dp[i - 2] + std::abs(h[i - 2] - h[i]));
}
std::cout << dp[n] << std::endl;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
typedef long long LL;
int int_vector_find(std::vector<int> vec, int num) {
auto itr = std::find(vec.begin(), vec.end(), num);
int index = std::distance(vec.begin(), itr);
if (index != vec.size()) {
return 1;
} else {
return 0;
}
}
int n;
LL h[100010], dp[100010];
int main() {
std::cin >> n;
for (int i = 1; i <= n; ++i) {
std::cin >> h[i];
dp[i] = 1000000000;
}
dp[1] = 0;
for (int i = 2; i <= n; ++i) {
if (i == 2) {
dp[i] = dp[i - 1] + std::abs(h[i - 1] - h[i]);
} else {
dp[i] = std::min(dp[i - 1] + std::abs(h[i - 1] - h[i]),
dp[i - 2] + std::abs(h[i - 2] - h[i]));
}
}
std::cout << dp[n] << std::endl;
} | [
"control_flow.branch.else.add"
] | 956,225 | 956,226 | u085117197 | cpp |
p03160 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
typedef long long LL;
int int_vector_find(std::vector<int> vec, int num) {
auto itr = std::find(vec.begin(), vec.end(), num);
int index = std::distance(vec.begin(), itr);
if (index != vec.size()) {
return 1;
} else {
return 0;
}
}
int n;
int h[100010], dp[100010];
int main() {
std::cin >> n;
for (int i = 1; i <= n; ++i) {
std::cin >> h[i];
dp[i] = 1000000000;
}
dp[1] = 0;
for (int i = 2; i <= n; ++i) {
if (i == 2) {
dp[i] = dp[i - 1] + std::abs(h[i - 1] - h[i]);
}
dp[i] = std::min(dp[i - 1] + std::abs(h[i - 1] - h[i]),
dp[i - 2] + std::abs(h[i - 2] - h[i]));
}
std::cout << dp[n] << std::endl;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
typedef long long LL;
int int_vector_find(std::vector<int> vec, int num) {
auto itr = std::find(vec.begin(), vec.end(), num);
int index = std::distance(vec.begin(), itr);
if (index != vec.size()) {
return 1;
} else {
return 0;
}
}
int n;
LL h[100010], dp[100010];
int main() {
std::cin >> n;
for (int i = 1; i <= n; ++i) {
std::cin >> h[i];
dp[i] = 1000000000;
}
dp[1] = 0;
for (int i = 2; i <= n; ++i) {
if (i == 2) {
dp[i] = dp[i - 1] + std::abs(h[i - 1] - h[i]);
} else {
dp[i] = std::min(dp[i - 1] + std::abs(h[i - 1] - h[i]),
dp[i - 2] + std::abs(h[i - 2] - h[i]));
}
}
std::cout << dp[n] << std::endl;
} | [
"variable_declaration.type.change",
"control_flow.branch.else.add"
] | 956,227 | 956,226 | u085117197 | cpp |
p03160 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
typedef long long LL;
int int_vector_find(std::vector<int> vec, int num) {
auto itr = std::find(vec.begin(), vec.end(), num);
int index = std::distance(vec.begin(), itr);
if (index != vec.size()) {
return 1;
} else {
return 0;
}
}
int n;
int h[100010], g[100010];
int main() {
std::cin >> n;
for (int i = 1; i <= n; ++i) {
std::cin >> h[i];
g[i] = 10000;
}
g[1] = 0;
for (int i = 2; i <= n; ++i) {
if (i == 2) {
g[i] = g[i - 1] + std::abs(g[i - 1] - h[i]);
} else {
g[i] = std::min(g[i - 1] + std::abs(h[i - 1] - h[i]),
g[i - 2] + std::abs(h[i - 2] - h[i]));
}
}
std::cout << g[n] << std::endl;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
typedef long long LL;
int int_vector_find(std::vector<int> vec, int num) {
auto itr = std::find(vec.begin(), vec.end(), num);
int index = std::distance(vec.begin(), itr);
if (index != vec.size()) {
return 1;
} else {
return 0;
}
}
int n;
long long h[100010], g[100010];
int main() {
std::cin >> n;
for (int i = 1; i <= n; ++i) {
std::cin >> h[i];
g[i] = 1000000000;
}
g[1] = 0;
for (int i = 2; i <= n; ++i) {
if (i == 2) {
g[i] = g[i - 1] + std::abs(h[i - 1] - h[i]);
} else {
g[i] = std::min(g[i - 1] + std::abs(h[i - 1] - h[i]),
g[i - 2] + std::abs(h[i - 2] - h[i]));
}
}
std::cout << g[n] << std::endl;
// system("pause");
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"literal.number.change",
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 956,228 | 956,229 | u085117197 | cpp |
p03160 | #include <cmath>
#include <iostream>
/* run this program using the console pauser or add your own getch,
* system("pause") or input loop */
using namespace std;
int main() {
int i, n;
cin >> n;
long long h[n], dp[n];
for (i = 0; i < n; i++) {
cin >> h[i];
}
dp[0] = 0;
dp[1] = abs(h[0] - h[1]);
for (i = 2; i < n; i++) {
dp[i] =
min((dp[i - 1] + (h[i] - h[i - 1])), (dp[i - 2] + (h[i] - h[i - 2])));
}
cout << dp[n - 2];
return 0;
}
| #include <cmath>
#include <iostream>
/* run this program using the console pauser or add your own getch,
* system("pause") or input loop */
using namespace std;
int main() {
int i, n;
cin >> n;
long long h[n], dp[n];
for (i = 0; i < n; i++) {
cin >> h[i];
}
dp[0] = 0;
dp[1] = abs(h[0] - h[1]);
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 - 1];
return 0;
}
| [
"call.add",
"call.arguments.change",
"literal.number.change",
"variable_access.subscript.index.change",
"io.output.change"
] | 956,230 | 956,231 | u700270455 | cpp |
p03160 | #include <cmath>
#include <iostream>
/* run this program using the console pauser or add your own getch,
* system("pause") or input loop */
using namespace std;
int main() {
int i, n;
cin >> n;
long long h[n], dp[n];
for (i = 0; i < n; i++) {
cin >> h[i];
}
dp[0] = 0;
dp[1] = abs(h[0] - h[1]);
for (i = 2; i < n; i++) {
dp[i] =
min((dp[i - 1] + (h[i] - h[i - 1])), (dp[i - 2] + (h[i] - h[i - 2])));
}
cout << dp[n - 1];
return 0;
}
| #include <cmath>
#include <iostream>
/* run this program using the console pauser or add your own getch,
* system("pause") or input loop */
using namespace std;
int main() {
int i, n;
cin >> n;
long long h[n], dp[n];
for (i = 0; i < n; i++) {
cin >> h[i];
}
dp[0] = 0;
dp[1] = abs(h[0] - h[1]);
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 - 1];
return 0;
}
| [
"call.add",
"call.arguments.change"
] | 956,232 | 956,231 | u700270455 | cpp |
p03160 | #include <algorithm>
#include <iostream>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
const long long INF = 1LL << 60;
int cost[1000000];
int main() {
int N;
cin >> N;
for (int i = 0; i < 1000000; i++) {
cost[i] = INF;
}
cost[0] = 0;
vector<int> H(N);
for (int i = 0; i < N; i++) {
cin >> H.at(i);
}
for (int i = 0; i < N; i++) {
int c1;
int c2;
if (i + 1 < N) {
c1 = abs(H.at(i) - H.at(i + 1)) + cost[i];
if (c1 < cost[i + 1]) {
cost[i + 1] = c1;
}
}
if (i + 2 < N) {
c2 = abs(H.at(i) - H.at(i + 2)) + cost[i];
if (c2 < cost[i + 2]) {
cost[i + 2] = c2;
}
}
}
cout << cost[N - 1];
}
| #include <algorithm>
#include <iostream>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
const long long INF = 1LL << 30;
int cost[1000000];
int main() {
int N;
cin >> N;
for (int i = 0; i < 1000000; i++) {
cost[i] = INF;
}
cost[0] = 0;
vector<int> H(N);
for (int i = 0; i < N; i++) {
cin >> H.at(i);
}
for (int i = 0; i < N; i++) {
int c1;
int c2;
if (i + 1 < N) {
c1 = abs(H.at(i) - H.at(i + 1)) + cost[i];
if (c1 < cost[i + 1]) {
cost[i + 1] = c1;
}
}
if (i + 2 < N) {
c2 = abs(H.at(i) - H.at(i + 2)) + cost[i];
if (c2 < cost[i + 2]) {
cost[i + 2] = c2;
}
}
}
cout << cost[N - 1];
}
| [
"literal.number.change",
"expression.operation.binary.change"
] | 956,246 | 956,247 | u015914170 | cpp |
p03160 | #include <algorithm>
#include <iostream>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
const long long INF = 1LL << 60;
int cost[100010];
int main() {
int N;
cin >> N;
for (int i = 0; i < 100010; i++) {
cost[i] = INF;
}
cost[0] = 0;
vector<int> H(N);
for (int i = 0; i < N; i++) {
cin >> H.at(i);
}
for (int i = 0; i < N; i++) {
int c1;
int c2;
if (i + 1 < N) {
c1 = abs(H.at(i) - H.at(i + 1)) + cost[i];
if (c1 < cost[i + 1]) {
cost[i + 1] = c1;
}
}
if (i + 2 < N) {
c2 = abs(H.at(i) - H.at(i + 2)) + cost[i];
if (c2 < cost[i + 2]) {
cost[i + 2] = c2;
}
}
}
cout << cost[N - 1];
}
| #include <algorithm>
#include <iostream>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
const long long INF = 1LL << 30;
int cost[1000000];
int main() {
int N;
cin >> N;
for (int i = 0; i < 1000000; i++) {
cost[i] = INF;
}
cost[0] = 0;
vector<int> H(N);
for (int i = 0; i < N; i++) {
cin >> H.at(i);
}
for (int i = 0; i < N; i++) {
int c1;
int c2;
if (i + 1 < N) {
c1 = abs(H.at(i) - H.at(i + 1)) + cost[i];
if (c1 < cost[i + 1]) {
cost[i + 1] = c1;
}
}
if (i + 2 < N) {
c2 = abs(H.at(i) - H.at(i + 2)) + cost[i];
if (c2 < cost[i + 2]) {
cost[i + 2] = c2;
}
}
}
cout << cost[N - 1];
}
| [
"literal.number.change",
"expression.operation.binary.change",
"variable_declaration.array_dimensions.change",
"control_flow.loop.for.condition.change"
] | 956,248 | 956,247 | u015914170 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int dp[100000];
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
dp[i] = 100000;
}
dp[0] = 0;
for (int i = 0; i < n; i++) {
int next = i + 1, nn = i + 2;
if (next < n)
dp[next] = min(dp[next], dp[i] + abs(arr[next] - arr[i]));
if (nn < n)
dp[nn] = min(dp[nn], dp[i] + abs(arr[nn] - arr[i]));
}
cout << dp[n - 1];
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int dp[100000];
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
dp[i] = INT_MAX;
}
dp[0] = 0;
for (int i = 0; i < n; i++) {
int next = i + 1, nn = i + 2;
if (next < n)
dp[next] = min(dp[next], dp[i] + abs(arr[next] - arr[i]));
if (nn < n)
dp[nn] = min(dp[nn], dp[i] + abs(arr[nn] - arr[i]));
}
cout << dp[n - 1];
return 0;
} | [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 956,254 | 956,255 | u116683591 | cpp |
p03160 | #include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define FASTIO \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define IN freopen("input.txt", "r", stdin);
#define OUT freopen("output.txt", "w", stdout);
#define LL long long
#define MOD 1000000007
#define INF 1000000000000000000
#define all(x) (x).begin(), (x).end()
#define pb(x) push_back(x)
using namespace std;
const int N = 1e5 + 1;
int n, F[N], h[N];
int main() {
IN;
FASTIO;
cin >> n;
for (int i = 1; i <= n; i++)
cin >> h[i];
h[0] = -1e8;
for (int i = 2; i <= n; i++) {
F[i] = F[i - 1] + abs(h[i] - h[i - 1]);
F[i] = min(F[i], F[i - 2] + abs(h[i] - h[i - 2]));
}
cout << F[n];
return 0;
}
| #include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define FASTIO \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define IN freopen("input.txt", "r", stdin);
#define OUT freopen("output.txt", "w", stdout);
#define LL long long
#define MOD 1000000007
#define INF 1000000000000000000
#define all(x) (x).begin(), (x).end()
#define pb(x) push_back(x)
using namespace std;
const int N = 1e5 + 1;
int n, F[N], h[N];
int main() {
// IN;
FASTIO;
cin >> n;
for (int i = 1; i <= n; i++)
cin >> h[i];
h[0] = -1e8;
for (int i = 2; i <= n; i++) {
F[i] = F[i - 1] + abs(h[i] - h[i - 1]);
F[i] = min(F[i], F[i - 2] + abs(h[i] - h[i - 2]));
}
cout << F[n];
return 0;
}
| [] | 956,258 | 956,259 | u030635914 | cpp |
p03160 | #include <bits/stdc++.h>
#define ll long long
#define iof \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
#define pi 3.1415926535897
#define mod 1000000007
#define inf (1ll << 60)
#include <fstream>
using namespace std;
int main() {
iof;
ll n;
cin >> n;
ll arr[n];
for (ll i = 0; i < n; i++)
cin >> arr[i];
ll dp[n + 1] = {0};
dp[0] = 0;
dp[1] = arr[1] - arr[0];
for (ll i = 2; i < n; i++) {
dp[i] = min(abs(arr[i] - arr[i - 2]) + dp[i - 2],
abs(arr[i] - arr[i - 1]) + dp[i - 1]);
}
cout << dp[n - 1] << endl;
}
| #include <bits/stdc++.h>
#define ll long long
#define iof \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
#define pi 3.1415926535897
#define mod 1000000007
#define inf (1ll << 60)
#include <fstream>
using namespace std;
int main() {
iof;
ll n;
cin >> n;
ll arr[n];
for (ll i = 0; i < n; i++)
cin >> arr[i];
ll dp[n + 1] = {0};
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 - 2]) + dp[i - 2],
abs(arr[i] - arr[i - 1]) + dp[i - 1]);
}
cout << dp[n - 1] << endl;
}
| [
"call.add",
"call.arguments.change"
] | 956,260 | 956,261 | u872560853 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
template <typename T> T load() {
T r;
cin >> r;
return r;
}
template <typename T> vector<T> loadMany(int n) {
vector<T> rs(n);
generate(rs.begin(), rs.end(), &load<T>);
return rs;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
auto n = load<int>();
auto height = loadMany<int>(n);
auto dyn = vector<int>(n);
dyn[0] = 0;
for (auto i = 1; i < n; ++i) {
dyn[i] = dyn[i - 0] + abs(height[i - 1] - height[i]);
if (i >= 2)
dyn[i] = min(dyn[i], dyn[i - 2] + abs(height[i] - height[i - 2]));
}
cout << dyn[n - 1] << '\n';
}
| #include <bits/stdc++.h>
using namespace std;
template <typename T> T load() {
T r;
cin >> r;
return r;
}
template <typename T> vector<T> loadMany(int n) {
vector<T> rs(n);
generate(rs.begin(), rs.end(), &load<T>);
return rs;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
auto n = load<int>();
auto height = loadMany<int>(n);
auto dyn = vector<int>(n);
dyn[0] = 0;
for (auto i = 1; i < n; ++i) {
dyn[i] = dyn[i - 1] + abs(height[i - 1] - height[i]);
if (i >= 2)
dyn[i] = min(dyn[i], dyn[i - 2] + abs(height[i] - height[i - 2]));
}
cout << dyn[n - 1] << '\n';
}
| [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 956,266 | 956,267 | u870233611 | cpp |
p03160 | #include <iostream>
#include <vector>
using namespace std;
int min(int a, int b) { return (a < b ? a : b); }
int abso(int x) { return (x >= 0 ? x : -x); }
static const int INF = 1e9;
int main() {
int n;
cin >> n;
vector<int> h(n + 1);
vector<int> dp(n + 1);
for (int i = 0; i < n; i++)
cin >> h[i + 1], dp[i] = INF;
dp[n] = INF;
dp[1] = 0;
for (int i = 1; i <= n; i++) {
if (i + 1 <= n)
dp[i + 1] = min(dp[i + 1], dp[i] + abso(h[i] - h[i + 1]));
if (i + 2 <= n)
dp[i + 2] = min(dp[i + 2], dp[i] + abso(h[i] - h[i + 1]));
}
cout << dp[n] << endl;
} | #include <iostream>
#include <vector>
using namespace std;
int min(int a, int b) { return (a < b ? a : b); }
int abso(int x) { return (x >= 0 ? x : -x); }
static const int INF = 1e9;
int main() {
int n;
cin >> n;
vector<int> h(n + 1);
vector<int> dp(n + 1);
for (int i = 0; i < n; i++)
cin >> h[i + 1], dp[i] = INF;
dp[n] = INF;
dp[1] = 0;
for (int i = 1; i <= n; i++) {
if (i + 1 <= n)
dp[i + 1] = min(dp[i + 1], dp[i] + abso(h[i] - h[i + 1]));
if (i + 2 <= n)
dp[i + 2] = min(dp[i + 2], dp[i] + abso(h[i] - h[i + 2]));
}
cout << dp[n] << endl;
} | [
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 956,275 | 956,276 | u430385413 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define int long long
signed main() {
cin.tie(0), cout.tie(0), ios::sync_with_stdio(0);
int n;
cin >> n;
vector<int> vec(n + 1);
for (int i = 1; i <= n; i++)
cin >> vec[i];
vector<int> dp(n + 3, 1e12);
dp[1] = 0;
dp[2] = abs(vec[1] - vec[0]);
for (int i = 3; i <= n; i++) {
int a = dp[i - 1] + abs(vec[i - 1] - vec[i]);
int b = dp[i - 2] + abs(vec[i - 2] - vec[i]);
dp[i] = min(a, b);
}
cout << dp[n] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
signed main() {
cin.tie(0), cout.tie(0), ios::sync_with_stdio(0);
int n;
cin >> n;
vector<int> vec(n + 1);
for (int i = 1; i <= n; i++)
cin >> vec[i];
vector<int> dp(n + 3, 1e12);
dp[1] = 0;
dp[2] = abs(vec[2] - vec[1]);
for (int i = 3; i <= n; i++) {
int a = dp[i - 1] + abs(vec[i - 1] - vec[i]);
int b = dp[i - 2] + abs(vec[i - 2] - vec[i]);
dp[i] = min(a, b);
}
cout << dp[n] << endl;
return 0;
}
| [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 956,279 | 956,280 | u370423102 | cpp |
p03160 | #include <bits/stdc++.h>
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
using namespace std;
int main() {
int n, i;
cin >> n;
int h[n + 1], dp[n + 1];
for (i = 1; i <= n; i++) {
cin >> h[i];
}
h[0] = 0;
dp[0] = 0;
dp[1] = 0;
for (i = 1; i < n; i++) {
dp[i + 1] =
MIN(dp[i] + abs(h[i] - h[i + 1]), dp[i - 1] + abs(h[i - 1] - h[i + 1]));
}
cout << dp[n] << endl;
} | #include <bits/stdc++.h>
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
using namespace std;
int main() {
int n, i;
cin >> n;
int h[n + 1], dp[n + 1];
for (i = 1; i <= n; i++) {
cin >> h[i];
}
h[0] = 0;
dp[0] = 1000000;
dp[1] = 0;
for (i = 1; i < n; i++) {
dp[i + 1] =
MIN(dp[i] + abs(h[i] - h[i + 1]), dp[i - 1] + abs(h[i - 1] - h[i + 1]));
}
cout << dp[n] << endl;
} | [
"literal.number.change",
"assignment.value.change"
] | 956,281 | 956,282 | u898143674 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> h(N);
h.at(0) = 0;
for (int i = 0; i < N; i++) {
cin >> h.at(i);
}
vector<int> cost(N);
cost.at(0) = 0;
cost.at(1) = h.at(1) - h.at(0);
for (int i = 2; i < N; i++) {
cost.at(i) = min(cost.at(i - 2) + abs(h.at(i) - h.at(i - 2)),
cost.at(i - 1) + abs(h.at(i) - h.at(i - 1)));
}
cout << cost.at(N - 1) << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> h(N);
h.at(0) = 0;
for (int i = 0; i < N; i++) {
cin >> h.at(i);
}
vector<int> cost(N);
cost.at(0) = 0;
cost.at(1) = abs(h.at(1) - h.at(0));
for (int i = 2; i < N; i++) {
cost.at(i) = min(cost.at(i - 2) + abs(h.at(i) - h.at(i - 2)),
cost.at(i - 1) + abs(h.at(i) - h.at(i - 1)));
}
cout << cost.at(N - 1) << endl;
} | [
"call.add",
"call.arguments.change"
] | 956,283 | 956,284 | u995725911 | cpp |
p03160 | #include <algorithm>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <map>
#include <math.h>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (long(i) = 0; (i) < (long)(n); (i)++)
#define rep1(i, n) for (int i = 1; i <= (n); i++)
#define rrep(i, a, b) for (long i = (a); i < (b); i++)
#define rrep1(i, a, b) for (long i = (a); i <= (b); i++)
#define rrrep(i, a, b) for (long i = (a); i >= (b); i--)
#define define pb push_back
#define ALL(obj) (obj).begin(), (obj).end()
#define X first
#define Y second
#define vi vector<int>
#define vl vector<ll>
#define vvi vector<vector<int>>
#define vpl vector<pair<long, long>>
#define vppl vector<pair<long, pair<long, long>>>
const int INF = 100100100;
const long LONG_INF = 2147483647;
const int MOD = (int)1e9 + 7;
const double EPS = 1e-9;
const ll LINF = 1e18;
int pow(int x) {
if (x == 0) {
return 1;
} else {
return pow(x - 1) * 2;
}
}
int main(int argc, char const *argv[]) {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vl h(n), dp(n);
rep1(i, n) { cin >> h[i]; }
dp[1] = 0;
dp[2] = h[2] - h[1];
rrep1(i, 3, n) {
int a, b;
a = dp[i - 2] + abs(h[i - 2] - h[i]);
b = dp[i - 1] + abs(h[i - 1] - h[i]);
if (a <= b) {
dp[i] = a;
} else {
dp[i] = b;
}
}
cout << dp[n] << endl;
return 0;
}
| #include <algorithm>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <map>
#include <math.h>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (long(i) = 0; (i) < (long)(n); (i)++)
#define rep1(i, n) for (int i = 1; i <= (n); i++)
#define rrep(i, a, b) for (long i = (a); i < (b); i++)
#define rrep1(i, a, b) for (long i = (a); i <= (b); i++)
#define rrrep(i, a, b) for (long i = (a); i >= (b); i--)
#define define pb push_back
#define ALL(obj) (obj).begin(), (obj).end()
#define X first
#define Y second
#define vi vector<int>
#define vl vector<ll>
#define vvi vector<vector<int>>
#define vpl vector<pair<long, long>>
#define vppl vector<pair<long, pair<long, long>>>
const int INF = 100100100;
const long LONG_INF = 2147483647;
const int MOD = (int)1e9 + 7;
const double EPS = 1e-9;
const ll LINF = 1e18;
int pow(int x) {
if (x == 0) {
return 1;
} else {
return pow(x - 1) * 2;
}
}
int main(int argc, char const *argv[]) {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vl h(n), dp(n);
rep1(i, n) { cin >> h[i]; }
dp[1] = 0;
dp[2] = abs(h[2] - h[1]);
rrep1(i, 3, n) {
int a, b;
a = dp[i - 2] + abs(h[i - 2] - h[i]);
b = dp[i - 1] + abs(h[i - 1] - h[i]);
if (a <= b) {
dp[i] = a;
} else {
dp[i] = b;
}
}
cout << dp[n] << endl;
return 0;
}
| [
"call.add",
"call.arguments.change"
] | 956,285 | 956,286 | u060896757 | cpp |
p03160 | #include <iostream>
#include <vector>
using namespace std;
/*template*/
template <class T> inline bool amax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool amin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
#define int long long
const int INF = 1001001001;
signed main() {
int n;
cin >> n;
vector<int> h(n);
for (int i = 0, i_len = (int)n; i < i_len; ++i)
cin >> h[i];
vector<int> dp(n + 1, INF);
dp[0] = 0;
dp[1] = (int)abs(h[0] - h[1]);
/*
dp[2] = (int)abs(h[1] - h[2]);
dp[2] = (int)abs(h[0] - h[2]);
amin(dp[2], dp[1] + (int)abs(h[1] - h[2]));
amin(dp[2], dp[0] + (int)abs(h[0] - h[2]));
amin(dp[i], dp[i-1] + (int)abs(h[i-1] - h[i]));
amin(dp[i], dp[i-2] + (int)abs(h[i-2] - h[i]));
*/
for (int i = 2; i < n; ++i) {
amin(dp[i], dp[i - 1] + (int)abs(h[i - 1] - h[i]));
amin(dp[i], dp[i - 2] + (int)abs(h[i - 2] - h[i]));
}
cout << dp[n] << endl;
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
/*template*/
template <class T> inline bool amax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool amin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
#define int long long
const int INF = 1001001001;
signed main() {
int n;
cin >> n;
vector<int> h(n);
for (int i = 0, i_len = (int)n; i < i_len; ++i)
cin >> h[i];
vector<int> dp(n + 1, INF);
dp[0] = 0;
dp[1] = (int)abs(h[0] - h[1]);
/*
dp[2] = (int)abs(h[1] - h[2]);
dp[2] = (int)abs(h[0] - h[2]);
amin(dp[2], dp[1] + (int)abs(h[1] - h[2]));
amin(dp[2], dp[0] + (int)abs(h[0] - h[2]));
amin(dp[i], dp[i-1] + (int)abs(h[i-1] - h[i]));
amin(dp[i], dp[i-2] + (int)abs(h[i-2] - h[i]));
*/
for (int i = 2; i < n; ++i) {
amin(dp[i], dp[i - 1] + (int)abs(h[i - 1] - h[i]));
amin(dp[i], dp[i - 2] + (int)abs(h[i - 2] - h[i]));
}
cout << dp[n - 1] << endl;
return 0;
} | [
"expression.operation.binary.add"
] | 956,287 | 956,288 | u509680664 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int maxi = 1e4 + 1;
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int dp[n] = {};
for (int i = 0; i < n; i++) {
dp[i] = maxi;
}
dp[0] = 0;
for (int i = 0; i < n - 1; i++) {
for (int j = 1; j < 3 && i + j < n; j++) {
dp[i + j] = min(dp[i + j], dp[i] + abs(arr[i] - arr[i + j]));
}
}
cout << dp[n - 1] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int INF = 1e9 + 1;
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int dp[n] = {};
for (int i = 0; i < n; i++) {
dp[i] = INF;
}
dp[0] = 0;
for (int i = 0; i < n - 1; i++) {
for (int j = 1; j < 3 && i + j < n; j++) {
dp[i + j] = min(dp[i + j], dp[i] + abs(arr[i] - arr[i + j]));
}
}
cout << dp[n - 1] << endl;
return 0;
} | [
"variable_declaration.name.change",
"identifier.change",
"literal.number.change",
"expression.operation.binary.change",
"assignment.value.change"
] | 956,291 | 956,292 | u768225950 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int maxi = 1e4;
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int dp[n] = {};
for (int i = 0; i < n; i++) {
dp[i] = maxi;
}
dp[0] = 0;
for (int i = 0; i < n - 1; i++) {
for (int j = 1; j < 3 && i + j < n; j++) {
dp[i + j] = min(dp[i + j], dp[i] + abs(arr[i] - arr[i + j]));
}
}
cout << dp[n - 1] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int INF = 1e9 + 1;
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int dp[n] = {};
for (int i = 0; i < n; i++) {
dp[i] = INF;
}
dp[0] = 0;
for (int i = 0; i < n - 1; i++) {
for (int j = 1; j < 3 && i + j < n; j++) {
dp[i + j] = min(dp[i + j], dp[i] + abs(arr[i] - arr[i + j]));
}
}
cout << dp[n - 1] << endl;
return 0;
} | [
"variable_declaration.name.change",
"identifier.change",
"literal.number.change",
"assignment.value.change"
] | 956,293 | 956,292 | u768225950 | cpp |
p03160 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
const int inf = 1LL << 60;
int main() {
int N;
cin >> N;
ll dp[100010];
ll h[100010];
for (int i = 0; i < N; i++) {
cin >> h[i];
}
for (int j = 0; j < 100010; j++) {
dp[j] = inf;
}
dp[0] = 0;
for (int i = 1; i < N; i++) {
dp[i] = min(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
if (i > 1) {
dp[i] = min(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
}
cout << dp[N - 1] << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
const ll inf = 1LL << 60;
int main() {
int N;
cin >> N;
ll dp[100010];
ll h[100010];
for (int i = 0; i < N; i++) {
cin >> h[i];
}
for (int j = 0; j < 100010; j++) {
dp[j] = inf;
}
dp[0] = 0;
for (int i = 1; i < N; i++) {
dp[i] = min(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
if (i > 1) {
dp[i] = min(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
}
cout << dp[N - 1] << endl;
return 0;
}
| [
"variable_declaration.type.change"
] | 956,294 | 956,295 | u904123392 | cpp |
p03160 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
const int inf = 1LL << 60;
int main() {
int N;
cin >> N;
ll dp[100010];
ll h[100010];
for (int i = 0; i < N; i++) {
cin >> h[i];
}
for (int j = 0; j < 100010; j++) {
dp[j] = inf;
}
dp[0] = 0;
for (int i = 1; i < N; i++) {
dp[i] = min(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
if (i > 1)
dp[i] = min(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
cout << dp[N - 1] << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
const ll inf = 1LL << 60;
int main() {
int N;
cin >> N;
ll dp[100010];
ll h[100010];
for (int i = 0; i < N; i++) {
cin >> h[i];
}
for (int j = 0; j < 100010; j++) {
dp[j] = inf;
}
dp[0] = 0;
for (int i = 1; i < N; i++) {
dp[i] = min(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
if (i > 1) {
dp[i] = min(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
}
cout << dp[N - 1] << endl;
return 0;
}
| [
"variable_declaration.type.change"
] | 956,296 | 956,295 | u904123392 | cpp |
p03160 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
const int inf = 1LL << 60;
int main() {
int N;
cin >> N;
ll dp[10010];
ll h[10010];
for (int i = 0; i < N; i++) {
cin >> h[i];
}
for (int j = 0; j < 10010; j++) {
dp[j] = inf;
}
dp[0] = 0;
for (int i = 1; i < N; i++) {
dp[i] = min(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
if (i > 1)
dp[i] = min(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
cout << dp[N - 1] << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
const ll inf = 1LL << 60;
int main() {
int N;
cin >> N;
ll dp[100010];
ll h[100010];
for (int i = 0; i < N; i++) {
cin >> h[i];
}
for (int j = 0; j < 100010; j++) {
dp[j] = inf;
}
dp[0] = 0;
for (int i = 1; i < N; i++) {
dp[i] = min(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
if (i > 1) {
dp[i] = min(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
}
cout << dp[N - 1] << endl;
return 0;
}
| [
"variable_declaration.type.change",
"literal.number.change",
"variable_declaration.array_dimensions.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 956,297 | 956,295 | u904123392 | cpp |
p03160 | /*author : Yashvardhan
Saturday, January 12, 2019
*/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define int ll
#define pb push_back
#define vi vector<int>
#define pi pair<int, int>
#define vpi vector<pi>
#define ff first
#define ss second
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("O3")
#pragma GCC optimize("O2")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define _CRT_SECURE_NO_WARNINGS
#ifdef __APPLE__
#define debug(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " ";
__f(comma + 1, args...);
}
#else
#define debug(...)
#endif
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
for (int i = 0; i < v.size(); ++i)
os << v[i] << " ";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const set<T> &v) {
for (auto it : v)
os << it << " ";
return os;
}
template <typename T, typename S>
ostream &operator<<(ostream &os, const pair<T, S> &v) {
os << v.ff << " " << v.ss;
return os;
}
const int mod = 1e9 + 7;
const int inf = 2e18;
const int ninf = -2e18;
int dp[100005];
int pow(int a, int b, int m) {
int ans = 1;
while (b) {
if (b & 1)
ans = (ans * a) % m;
b /= 2;
a = (a * a) % m;
}
return ans;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
#ifdef __APPLE__
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
freopen("error.txt", "w", stderr);
#endif
time_t t1, t2;
t1 = clock();
int n;
cin >> n;
int hs[n + 1];
for (int i = 1; i <= n; i++) {
cin >> hs[i];
}
dp[1] = 0;
dp[2] = abs(hs[2] - hs[1]);
for (int i = 2; i <= n; i++) {
dp[i] = min((dp[i - 1] + abs(hs[i - 1] - hs[i])),
(dp[i - 2] + abs(hs[i - 2] - hs[i])));
}
cout << dp[n] << endl;
t2 = clock();
cerr << endl << t2 - t1 << endl;
return 0;
}
| /*author : Yashvardhan
Saturday, January 12, 2019
*/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define int ll
#define pb push_back
#define vi vector<int>
#define pi pair<int, int>
#define vpi vector<pi>
#define ff first
#define ss second
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("O3")
#pragma GCC optimize("O2")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define _CRT_SECURE_NO_WARNINGS
#ifdef __APPLE__
#define debug(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " ";
__f(comma + 1, args...);
}
#else
#define debug(...)
#endif
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
for (int i = 0; i < v.size(); ++i)
os << v[i] << " ";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const set<T> &v) {
for (auto it : v)
os << it << " ";
return os;
}
template <typename T, typename S>
ostream &operator<<(ostream &os, const pair<T, S> &v) {
os << v.ff << " " << v.ss;
return os;
}
const int mod = 1e9 + 7;
const int inf = 2e18;
const int ninf = -2e18;
int dp[100005];
int pow(int a, int b, int m) {
int ans = 1;
while (b) {
if (b & 1)
ans = (ans * a) % m;
b /= 2;
a = (a * a) % m;
}
return ans;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
#ifdef __APPLE__
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
freopen("error.txt", "w", stderr);
#endif
time_t t1, t2;
t1 = clock();
int n;
cin >> n;
int hs[n + 1];
for (int i = 1; i <= n; i++) {
cin >> hs[i];
}
dp[1] = 0;
dp[2] = abs(hs[2] - hs[1]);
for (int i = 3; i <= n; i++) {
dp[i] = min((dp[i - 1] + abs(hs[i - 1] - hs[i])),
(dp[i - 2] + abs(hs[i - 2] - hs[i])));
}
cout << dp[n] << endl;
t2 = clock();
cerr << endl << t2 - t1 << endl;
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 956,303 | 956,304 | u368039995 | cpp |
p03160 | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
const long long INF = 1LL << 8;
int main() {
int n;
cin >> n;
vector<ll> h(n);
for (int i = 0; i < n; i++)
cin >> h[i];
vector<ll> dp(100010, INF);
dp[0] = 0;
for (int i = 1; i < n; i++) {
//隣にジャンプ
dp[i] = min(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
// 1つ飛ばして
if (i > 1)
dp[i] = min(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
cout << dp[n - 1] << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
const long long INF = 1e9;
int main() {
int n;
cin >> n;
vector<ll> h(n);
for (int i = 0; i < n; i++)
cin >> h[i];
vector<ll> dp(100010, INF);
dp[0] = 0;
for (int i = 1; i < n; i++) {
//隣にジャンプ
dp[i] = min(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
// 1つ飛ばして
if (i > 1)
dp[i] = min(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
cout << dp[n - 1] << endl;
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 956,305 | 956,306 | u170650966 | cpp |
p03160 | #include <algorithm>
#include <iostream>
#include <stdio.h>
#include <vector>
using namespace std;
int N;
vector<int> memo, h;
int dp(vector<int> memo, vector<int> h) {
memo[0] = 0;
memo[1] = h[1] - h[0];
for (int i = 2; i < N; i++) {
int one = memo[i - 1] + abs(h[i] - h[i - 1]);
int two = memo[i - 2] + abs(h[i] - h[i - 2]);
memo[i] = min(one, two);
}
return memo[N - 1];
}
int main() {
scanf("%d", &N);
memo.resize(N);
h.resize(N);
for (int i = 0; i < N; i++)
cin >> h[i];
int MIN = dp(memo, h);
printf("%d\n", MIN);
}
| #include <algorithm>
#include <iostream>
#include <stdio.h>
#include <vector>
using namespace std;
int N;
vector<int> memo, h;
int dp(vector<int> memo, vector<int> h) {
memo[0] = 0;
memo[1] = abs(h[1] - h[0]);
for (int i = 2; i < N; i++) {
int one = memo[i - 1] + abs(h[i] - h[i - 1]);
int two = memo[i - 2] + abs(h[i] - h[i - 2]);
memo[i] = min(one, two);
}
return memo[N - 1];
}
int main() {
scanf("%d", &N);
memo.resize(N);
h.resize(N);
for (int i = 0; i < N; i++)
cin >> h[i];
int MIN = dp(memo, h);
printf("%d\n", MIN);
}
| [
"call.add",
"call.arguments.change"
] | 956,327 | 956,328 | u877476774 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> S(N);
for (int i = 0; i < N; i++) {
cin >> S.at(i);
}
vector<int> Cost(N);
Cost.at(0) = S.at(0);
Cost.at(1) = abs(S.at(1) - S.at(0));
for (int k = 2; k < N; k++) {
if (Cost.at(k - 1) + abs(S.at(k - 1) - S.at(k)) <
Cost.at(k - 2) + abs(S.at(k - 2) - S.at(k))) {
Cost.at(k) = Cost.at(k - 1) + abs(S.at(k - 1) - S.at(k));
} else {
Cost.at(k) = Cost.at(k - 2) + abs(S.at(k - 2) - S.at(k));
}
}
cout << Cost.at(N - 1) << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> S(N);
for (int i = 0; i < N; i++) {
cin >> S.at(i);
}
vector<int> Cost(N);
Cost.at(0) = 0;
Cost.at(1) = abs(S.at(1) - S.at(0));
for (int k = 2; k < N; k++) {
if (Cost.at(k - 1) + abs(S.at(k - 1) - S.at(k)) <
Cost.at(k - 2) + abs(S.at(k - 2) - S.at(k))) {
Cost.at(k) = Cost.at(k - 1) + abs(S.at(k - 1) - S.at(k));
} else {
Cost.at(k) = Cost.at(k - 2) + abs(S.at(k - 2) - S.at(k));
}
}
cout << Cost.at(N - 1) << endl;
} | [
"call.remove",
"call.arguments.change"
] | 956,331 | 956,332 | u393754572 | cpp |
p03160 | #include <bits/stdc++.h>
#define ll long long int
#define dll long double
#define fli(j, n) for (int i = j; i < n; i++)
#define flj(i, n) for (int j = i; j < n; j++)
#define pb push_back
using namespace std;
auto fast_io = []() {
std::ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout.precision(10);
return nullptr;
}();
long long int n;
vector<long long int> h;
long long int has[100001];
long long int rec(long long int curr) {
if (curr == n)
return 0;
if (curr > n)
return 0;
if (has[curr] != -1)
return has[curr];
return has[curr] = min(abs(h[curr] - h[curr + 1]) + rec(curr + 1),
abs(h[curr] - h[curr + 2]) + rec(curr + 2));
}
int main() {
cin >> n;
memset(has, -1, sizeof(has));
for (long long int i = 0; i < n; i++) {
long long int o;
cin >> o;
h.push_back(o);
}
n--;
cout << rec(0);
return 0;
} | #include <bits/stdc++.h>
#define ll long long int
#define dll long double
#define fli(j, n) for (int i = j; i < n; i++)
#define flj(i, n) for (int j = i; j < n; j++)
#define pb push_back
using namespace std;
auto fast_io = []() {
std::ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout.precision(10);
return nullptr;
}();
long long int n;
vector<long long int> h;
long long int has[100001];
long long int rec(long long int curr) {
if (curr == n)
return 0;
if (curr > n)
return INT_MAX;
if (has[curr] != -1)
return has[curr];
return has[curr] = min(abs(h[curr] - h[curr + 1]) + rec(curr + 1),
abs(h[curr] - h[curr + 2]) + rec(curr + 2));
}
int main() {
cin >> n;
memset(has, -1, sizeof(has));
for (long long int i = 0; i < n; i++) {
long long int o;
cin >> o;
h.push_back(o);
}
n--;
cout << rec(0);
return 0;
} | [
"identifier.replace.add",
"literal.replace.remove",
"function.return_value.change"
] | 956,336 | 956,337 | u745901211 | cpp |
p03160 | // A - Frog 1
// 問題文
// N個の足場があります。 足場には 1,2,…,N と番号が振られています。 各 i (1≤i≤N)
// について、 足場 iの高さはhiです。最初、足場1にカエルがいます。
// カエルは次の行動を何回か繰り返し、足場 N
// まで辿り着こうとしています。足場iにいるとき、足場 i+1 または
// i+2へジャンプする。 このとき、ジャンプ先の足場を jとすると、コスト
// |hi−hj|を支払う。カエルが足場 Nに辿り着くまでに支払うコストの
// 総和の最小値を求めてください。
// 制約
// 入力はすべて整数である。
// 2≤N≤10の５乗
// 1≤hi≤10の4乗
// 入力
// 入力は以下の形式で標準入力から与えられる。
// N
// h1 h2 …hN
// 出力
// カエルが支払うコストの総和の最小値を出力せよ。
// 入力例 1
// Copy
// 4
// 10 30 40 20
// 出力例 1
// Copy
// 30
// 足場
// 1→ 2→ 4
// と移動すると、コストの総和は |10−30|+|30−20|=30となります。
// 入力例 2
// Copy
// 2
// 10 10
// 出力例 2
// Copy
// 0
// 足場
// 1→ 2と移動すると、コストの総和は |10−10|=0となります。
// 入力例 3
// Copy
// 6
// 30 10 60 10 60 50
// 出力例 3
// Copy
// 40
// 足場
// 1→ 3→ 5→ 6と移動すると、コストの総和は |30−60|+|60−60|+|60−50|=40となります。
// miss
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
using namespace std;
int main(void) {
long long N, h[100100] = {0};
long long dp[100100] = {0};
long long inf = 1e9;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> h[i];
}
for (int i = 0; i < N; i++) {
dp[i] = inf;
}
dp[0] = 0;
for (int i = 0; i < N; i++) {
dp[i + 1] = max(dp[i + 1], dp[i] + abs(h[i + 1] - h[i]));
dp[i + 2] = max(dp[i + 2], dp[i] + abs(h[i + 2] - h[i]));
}
cout << dp[N - 1] << endl;
return 0;
} | // A - Frog 1
// 問題文
// N個の足場があります。 足場には 1,2,…,N と番号が振られています。 各 i (1≤i≤N)
// について、 足場 iの高さはhiです。最初、足場1にカエルがいます。
// カエルは次の行動を何回か繰り返し、足場 N
// まで辿り着こうとしています。足場iにいるとき、足場 i+1 または
// i+2へジャンプする。 このとき、ジャンプ先の足場を jとすると、コスト
// |hi−hj|を支払う。カエルが足場 Nに辿り着くまでに支払うコストの
// 総和の最小値を求めてください。
// 制約
// 入力はすべて整数である。
// 2≤N≤10の５乗
// 1≤hi≤10の4乗
// 入力
// 入力は以下の形式で標準入力から与えられる。
// N
// h1 h2 …hN
// 出力
// カエルが支払うコストの総和の最小値を出力せよ。
// 入力例 1
// Copy
// 4
// 10 30 40 20
// 出力例 1
// Copy
// 30
// 足場
// 1→ 2→ 4
// と移動すると、コストの総和は |10−30|+|30−20|=30となります。
// 入力例 2
// Copy
// 2
// 10 10
// 出力例 2
// Copy
// 0
// 足場
// 1→ 2と移動すると、コストの総和は |10−10|=0となります。
// 入力例 3
// Copy
// 6
// 30 10 60 10 60 50
// 出力例 3
// Copy
// 40
// 足場
// 1→ 3→ 5→ 6と移動すると、コストの総和は |30−60|+|60−60|+|60−50|=40となります。
// miss
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
using namespace std;
int main(void) {
long long N, h[100100] = {0};
long long dp[100100] = {0};
long long inf = 1e9;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> h[i];
}
for (int i = 0; i < N; i++) {
dp[i] = inf;
}
dp[0] = 0;
for (int i = 0; i < N; i++) {
dp[i + 1] = min(dp[i + 1], dp[i] + abs(h[i + 1] - h[i]));
dp[i + 2] = min(dp[i + 2], dp[i] + abs(h[i + 2] - h[i]));
}
cout << dp[N - 1] << endl;
return 0;
} | [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 956,348 | 956,349 | u865595275 | cpp |
p03160 | #include <cmath>
#include <iostream>
#define int long long
using namespace std;
int v[500001], n;
int pd[1000001];
main() {
cin >> n;
for (int i = 1; i <= n; ++i)
cin >> v[i];
pd[1] = 0;
pd[2] = abs(v[1] - v[2]);
for (int i = 2; i <= n; ++i)
pd[i] = min(pd[i - 1] + (abs(v[i - 1] - v[i])),
pd[i - 2] + abs(v[i - 2] - v[i]));
cout << pd[n];
return 0;
}
| #include <cmath>
#include <iostream>
#define int long long
using namespace std;
int v[500001], n;
int pd[1000001];
main() {
cin >> n;
for (int i = 1; i <= n; ++i)
cin >> v[i];
pd[1] = 0;
pd[2] = abs(v[1] - v[2]);
for (int i = 3; i <= n; ++i)
pd[i] = min(pd[i - 1] + (abs(v[i - 1] - v[i])),
pd[i - 2] + abs(v[i - 2] - v[i]));
cout << pd[n];
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 956,356 | 956,357 | u360090477 | cpp |
p03160 | #include <cmath>
#include <iostream>
#define int long long
using namespace std;
int v[500001], n;
int pd[1000001];
main() {
cin >> n;
for (int i = 1; i <= n; ++i)
cin >> v[i];
pd[1] = 0;
pd[2] = abs(v[1] - v[2]);
for (int i = 2; i <= n; ++i)
pd[i] = min(pd[i - 1] + (abs(v[i - 1] - v[i])),
pd[i - 2] + abs(v[i] - v[i - 2]));
cout << pd[n];
return 0;
}
| #include <cmath>
#include <iostream>
#define int long long
using namespace std;
int v[500001], n;
int pd[1000001];
main() {
cin >> n;
for (int i = 1; i <= n; ++i)
cin >> v[i];
pd[1] = 0;
pd[2] = abs(v[1] - v[2]);
for (int i = 3; i <= n; ++i)
pd[i] = min(pd[i - 1] + (abs(v[i - 1] - v[i])),
pd[i - 2] + abs(v[i - 2] - v[i]));
cout << pd[n];
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"assignment.change",
"expression.operation.binary.remove"
] | 956,358 | 956,357 | u360090477 | cpp |
p03160 | #include <cmath>
#include <iostream>
#define int long long
using namespace std;
int v[100001], n;
int pd[1000001];
main() {
cin >> n;
for (int i = 1; i <= n; ++i)
cin >> v[i];
pd[1] = 0;
pd[2] = abs(v[1] - v[2]);
for (int i = 2; i <= n; ++i)
pd[i] = min(pd[i - 1] + (abs(v[i - 1] - v[i])),
pd[i - 2] + abs(v[i] - v[i - 2]));
cout << pd[n];
return 0;
}
| #include <cmath>
#include <iostream>
#define int long long
using namespace std;
int v[500001], n;
int pd[1000001];
main() {
cin >> n;
for (int i = 1; i <= n; ++i)
cin >> v[i];
pd[1] = 0;
pd[2] = abs(v[1] - v[2]);
for (int i = 3; i <= n; ++i)
pd[i] = min(pd[i - 1] + (abs(v[i - 1] - v[i])),
pd[i - 2] + abs(v[i - 2] - v[i]));
cout << pd[n];
return 0;
}
| [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"assignment.change",
"expression.operation.binary.remove"
] | 956,359 | 956,357 | u360090477 | cpp |
p03160 | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
int dp[n];
dp[0] = 0;
for (int i = 1; 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] << "\n";
return 0;
} | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
int dp[n];
dp[0] = 0;
for (int i = 1; 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 - 1] << "\n";
return 0;
} | [
"expression.operation.binary.add"
] | 956,360 | 956,361 | u853502765 | 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 + 1; i++)
cin >> arr[i];
int dp[n + 1];
dp[1] = arr[1];
dp[2] = abs(arr[2] - arr[1]);
for (int i = 3; i < n + 1; 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] << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n + 1];
for (int i = 1; i < n + 1; i++)
cin >> arr[i];
int dp[n + 1];
dp[1] = 0;
dp[2] = abs(arr[2] - arr[1]);
for (int i = 3; i < n + 1; 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] << endl;
} | [
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add"
] | 956,366 | 956,367 | u802236432 | cpp |
p03160 | #include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const long long INF = 1LL << 60;
int N;
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 = 0; i < N - 1; ++i) {
chmin(dp[i + 1], dp[i] + abs(h[i] - h[i - 1]));
if (i < N - 1)
chmin(dp[i + 2], dp[i] + abs(h[i] - h[i - 2]));
}
cout << dp[N - 1] << endl;
} | #include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const long long INF = 1LL << 60;
int N;
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 = 0; i < N - 1; ++i) {
chmin(dp[i + 1], dp[i] + abs(h[i] - h[i + 1]));
if (i < N - 1)
chmin(dp[i + 2], dp[i] + abs(h[i] - h[i + 2]));
}
cout << dp[N - 1] << endl;
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 956,374 | 956,375 | u785578220 | cpp |
p03160 | #include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const long long INF = 1LL << 60;
int N;
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 = 0; i < N - 1; ++i) {
chmin(dp[i + 1], dp[i] + abs(h[i] - h[i - 1]));
if (i < N - 2)
chmin(dp[i + 2], dp[i - 2] + abs(h[i] - h[i - 2]));
}
cout << dp[N - 1] << endl;
} | #include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const long long INF = 1LL << 60;
int N;
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 = 0; i < N - 1; ++i) {
chmin(dp[i + 1], dp[i] + abs(h[i] - h[i + 1]));
if (i < N - 1)
chmin(dp[i + 2], dp[i] + abs(h[i] - h[i + 2]));
}
cout << dp[N - 1] << endl;
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change",
"literal.number.change",
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 956,376 | 956,375 | u785578220 | cpp |
p03160 | #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using datas = pair<ll, ll>;
using ddatas = pair<double, double>;
using tdata = pair<ll, datas>;
using vec = vector<ll>;
using mat = vector<vec>;
using pvec = vector<datas>;
using pmat = vector<pvec>;
#define For(i, a, b) for (i = a; i < b; i++)
#define bFor(i, a, b) for (i = a; i >= b; i--)
#define rep(i, N) For(i, 0, N)
#define rep1(i, N) For(i, 1, N)
#define brep(i, N) bFor(i, N - 1, 0)
#define all(v) (v).begin(), (v).end()
#define allr(v) (v).rbegin(), (v).rend()
#define vsort(v) sort(all(v))
#define vrsort(v) sort(allr(v))
#define endl "\n"
#define output(v) \
do { \
bool f = 0; \
for (auto i : v) { \
cout << (f ? " " : "") << i; \
f = 1; \
} \
cout << endl; \
} while (0)
const ll mod = 1000000007;
const ll inf = 1LL << 60;
long mmid(long a, long b, long c) {
return a < b ? (b < c ? b : max(a, c)) : (b > c ? b : min(a, c));
}
double dist(ddatas &x, ddatas &y) {
double a = x.first - y.first, b = x.second - y.second;
return sqrt(a * a + b * b);
}
ll modinv(ll a) {
ll b = mod, u = 1, v = 0, t;
while (b) {
t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
return (u + mod) % mod;
}
ll moddevide(ll a, ll b) { return (a * modinv(b)) % mod; }
ll modncr(ll n, ll r) {
ll i, plus = 1;
rep(i, r) {
plus = (plus * (n - i)) % mod;
plus = moddevide(plus, i + 1);
}
return plus;
}
ll modncrlistp[200000], modncrlistm[200000];
ll modncrs(ll n, ll r) {
ll i, j;
if (modncrlistp[n] == 0) {
for (i = n; i >= 0; i--) {
if (modncrlistp[i])
break;
}
if (i < 0) {
modncrlistp[0] = 1;
rep1(i, n + 1) { modncrlistp[i] = (modncrlistp[i - 1] * i) % mod; }
} else {
For(j, i + 1, n + 1) { modncrlistp[j] = (modncrlistp[j - 1] * j) % mod; }
}
}
if (modncrlistm[n] == 0) {
for (i = n; i >= 0; i--) {
if (modncrlistm[i])
break;
}
if (i < 0) {
modncrlistm[0] = 1;
rep1(i, n + 1) {
modncrlistm[i] = (modncrlistm[i - 1] * modinv(i)) % mod;
}
} else {
For(j, i + 1, n + 1) modncrlistm[j] =
(modncrlistm[j - 1] * modinv(j)) % mod;
}
}
return (((modncrlistp[n] * modncrlistm[r]) % mod) * modncrlistm[n - r]) % mod;
}
ll gcd(ll a, ll b) {
if (!b)
return a;
return (a % b == 0) ? b : gcd(b, a % b);
}
ll countdigits(ll n) {
ll ans = 0;
while (n) {
n /= 10;
ans++;
}
return ans;
}
ll sumdigits(ll n) {
ll ans = 0;
while (n) {
ans += n % 10;
n /= 10;
}
return ans;
}
vec eratosthenes(ll N) {
ll i;
vec ch(N + 1, 1), p;
ch[0] = ch[1] = 0;
rep(i, N + 1) {
if (ch[i]) {
p.push_back(i);
for (ll j = 2; i * j <= N; j++) {
ch[i * j] = 0;
}
}
}
return ch;
}
int main() {
ll i, N, M, s, g, a, b, c, e, cnt = 1;
cin >> N;
vec dp(N), h(N);
rep(i, N) {
cin >> h[i];
if (i > 2) {
dp[i] = min(dp[i - 2] + labs(h[i - 2] - h[i]),
dp[i - 1] + labs(h[i - 1] - h[i]));
} else if (i) {
dp[i] = dp[i - 1] + labs(h[i - 1] - h[i]);
} else {
dp[i] = 0;
}
}
cout << dp[N - 1] << endl;
return 0;
} | #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using datas = pair<ll, ll>;
using ddatas = pair<double, double>;
using tdata = pair<ll, datas>;
using vec = vector<ll>;
using mat = vector<vec>;
using pvec = vector<datas>;
using pmat = vector<pvec>;
#define For(i, a, b) for (i = a; i < b; i++)
#define bFor(i, a, b) for (i = a; i >= b; i--)
#define rep(i, N) For(i, 0, N)
#define rep1(i, N) For(i, 1, N)
#define brep(i, N) bFor(i, N - 1, 0)
#define all(v) (v).begin(), (v).end()
#define allr(v) (v).rbegin(), (v).rend()
#define vsort(v) sort(all(v))
#define vrsort(v) sort(allr(v))
#define endl "\n"
#define output(v) \
do { \
bool f = 0; \
for (auto i : v) { \
cout << (f ? " " : "") << i; \
f = 1; \
} \
cout << endl; \
} while (0)
const ll mod = 1000000007;
const ll inf = 1LL << 60;
long mmid(long a, long b, long c) {
return a < b ? (b < c ? b : max(a, c)) : (b > c ? b : min(a, c));
}
double dist(ddatas &x, ddatas &y) {
double a = x.first - y.first, b = x.second - y.second;
return sqrt(a * a + b * b);
}
ll modinv(ll a) {
ll b = mod, u = 1, v = 0, t;
while (b) {
t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
return (u + mod) % mod;
}
ll moddevide(ll a, ll b) { return (a * modinv(b)) % mod; }
ll modncr(ll n, ll r) {
ll i, plus = 1;
rep(i, r) {
plus = (plus * (n - i)) % mod;
plus = moddevide(plus, i + 1);
}
return plus;
}
ll modncrlistp[200000], modncrlistm[200000];
ll modncrs(ll n, ll r) {
ll i, j;
if (modncrlistp[n] == 0) {
for (i = n; i >= 0; i--) {
if (modncrlistp[i])
break;
}
if (i < 0) {
modncrlistp[0] = 1;
rep1(i, n + 1) { modncrlistp[i] = (modncrlistp[i - 1] * i) % mod; }
} else {
For(j, i + 1, n + 1) { modncrlistp[j] = (modncrlistp[j - 1] * j) % mod; }
}
}
if (modncrlistm[n] == 0) {
for (i = n; i >= 0; i--) {
if (modncrlistm[i])
break;
}
if (i < 0) {
modncrlistm[0] = 1;
rep1(i, n + 1) {
modncrlistm[i] = (modncrlistm[i - 1] * modinv(i)) % mod;
}
} else {
For(j, i + 1, n + 1) modncrlistm[j] =
(modncrlistm[j - 1] * modinv(j)) % mod;
}
}
return (((modncrlistp[n] * modncrlistm[r]) % mod) * modncrlistm[n - r]) % mod;
}
ll gcd(ll a, ll b) {
if (!b)
return a;
return (a % b == 0) ? b : gcd(b, a % b);
}
ll countdigits(ll n) {
ll ans = 0;
while (n) {
n /= 10;
ans++;
}
return ans;
}
ll sumdigits(ll n) {
ll ans = 0;
while (n) {
ans += n % 10;
n /= 10;
}
return ans;
}
vec eratosthenes(ll N) {
ll i;
vec ch(N + 1, 1), p;
ch[0] = ch[1] = 0;
rep(i, N + 1) {
if (ch[i]) {
p.push_back(i);
for (ll j = 2; i * j <= N; j++) {
ch[i * j] = 0;
}
}
}
return ch;
}
int main() {
ll i, N, M, s, g, a, b, c, e, cnt = 1;
cin >> N;
vec dp(N), h(N);
rep(i, N) {
cin >> h[i];
if (i >= 2) {
dp[i] = min(dp[i - 2] + labs(h[i - 2] - h[i]),
dp[i - 1] + labs(h[i - 1] - h[i]));
} else if (i) {
dp[i] = dp[i - 1] + labs(h[i - 1] - h[i]);
} else {
dp[i] = 0;
}
}
cout << dp[N - 1] << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 956,381 | 956,382 | u251847465 | cpp |
p03160 | #include <bits/stdc++.h>
#define rep(i, a) for (int i = 0; i < int(a); ++i)
#define REP(i, a, b) for (int i = int(a); i < int(b); ++i)
#define pb push_back
#define mp make_pair
#define F first
#define S second
using ll = long long;
using itn = int;
using namespace std;
using Graph = vector<vector<int>>;
static const long double GRATIO = (long double)(1 + sqrt(5)) / 2;
ll GCD(ll a, ll b) { return b ? GCD(b, a % b) : a; }
ll LCM(ll a, ll b) { return a / GCD(a, b) * b; }
int main() {
int N;
cin >> N;
vector<int> h(N);
rep(i, N) cin >> h[i];
vector<int> dp(N, 1e9);
dp[0] = 0;
for (int i = 1; i < N; i++) {
if (i == 1) {
dp[i] = min(dp[i - 1] + abs(h[i - 1] - h[i]), dp[i]);
}
dp[i] = min(dp[i - 1] + abs(h[i - 1] - h[i]),
min(dp[i - 2] + abs(h[i - 2] - h[i]), dp[i]));
}
cout << dp[N - 1] << endl;
} | #include <bits/stdc++.h>
#define rep(i, a) for (int i = 0; i < int(a); ++i)
#define REP(i, a, b) for (int i = int(a); i < int(b); ++i)
#define pb push_back
#define mp make_pair
#define F first
#define S second
using ll = long long;
using itn = int;
using namespace std;
using Graph = vector<vector<int>>;
static const long double GRATIO = (long double)(1 + sqrt(5)) / 2;
ll GCD(ll a, ll b) { return b ? GCD(b, a % b) : a; }
ll LCM(ll a, ll b) { return a / GCD(a, b) * b; }
int main() {
int N;
cin >> N;
vector<int> h(N);
rep(i, N) cin >> h[i];
vector<int> dp(N, 1e9);
dp[0] = 0;
for (int i = 1; i < N; i++) {
if (i == 1) {
dp[i] = min(dp[i - 1] + abs(h[i - 1] - h[i]), dp[i]);
continue;
}
dp[i] = min(dp[i - 1] + abs(h[i - 1] - h[i]),
min(dp[i - 2] + abs(h[i - 2] - h[i]), dp[i]));
}
cout << dp[N - 1] << endl;
} | [] | 956,386 | 956,387 | u089885969 | 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] = {INT_MAX};
dp[0] = 0;
dp[1] = abs(h[1] - h[0]);
for (int i = 1; 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 - 1] << endl;
} | #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] = {INT_MAX};
dp[0] = 0;
dp[1] = abs(h[1] - h[0]);
for (int 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 - 1] << endl;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 956,390 | 956,391 | u370447425 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define ll long long
#define pii pair<int, int>
#define pll pair<long long, long long>
#define ull unsigned long long
#define mp make_pair
#define F first
#define S second
#define mod 1000000007
int a[100005];
int dp[100005];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i];
dp[1] = a[1] - a[0];
dp[0] = 0;
for (int i = 2; 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 pb push_back
#define ll long long
#define pii pair<int, int>
#define pll pair<long long, long long>
#define ull unsigned long long
#define mp make_pair
#define F first
#define S second
#define mod 1000000007
int a[100005];
int dp[100005];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i];
dp[1] = abs(a[1] - a[0]);
dp[0] = 0;
for (int i = 2; 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"
] | 956,392 | 956,393 | u923368296 | cpp |
p03160 | #include <iostream>
using namespace std;
int main() {
const long long INF = 1LL << 60;
int N;
cin >> N;
long long H[N];
for (int i = 0; i < N; ++i) {
cin >> H[i];
}
long long dp[N];
dp[0] = 0;
for (int i = 1; i < N; ++i) {
dp[i] = INF;
}
for (int i = 1; i < N; ++i) {
if (dp[i + 1] > dp[i] + abs(H[i] - H[i + 1]))
dp[i + 1] = dp[i] + abs(H[i] - H[i + 1]);
if (dp[i + 2] > dp[i] + abs(H[i] - H[i + 2]))
dp[i + 2] = dp[i] + abs(H[i] - H[i + 2]);
}
cout << dp[N - 1] << endl;
}
| #include <iostream>
using namespace std;
int main() {
const long long INF = 1LL << 60;
int N;
cin >> N;
long long H[N];
for (int i = 0; i < N; ++i) {
cin >> H[i];
}
long long dp[N];
dp[0] = 0;
for (int i = 1; i < N; ++i) {
dp[i] = INF;
}
for (int i = 0; i < N; ++i) {
if (dp[i + 1] > dp[i] + abs(H[i] - H[i + 1]))
dp[i + 1] = dp[i] + abs(H[i] - H[i + 1]);
if (dp[i + 2] > dp[i] + abs(H[i] - H[i + 2]))
dp[i + 2] = dp[i] + abs(H[i] - H[i + 2]);
}
cout << dp[N - 1] << endl;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 956,414 | 956,415 | u506858457 | cpp |
p03160 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
using namespace std;
const long long INF = 1LL << 60;
int main(void) {
int N;
cin >> N;
vector<int> h(N);
for (auto &x : h) {
cin >> x;
}
vector<int> dp(N, INF);
dp[0] = 0;
for (int i = 0; i < N - 1; i++) {
dp[i + 1] = min(abs(h[i] - h[i + 1]) + dp[i], dp[i + 1]);
if (i < N - 2)
dp[i + 2] = min(abs(h[i] - h[i + 2]) + dp[i], dp[i + 2]);
// cout << dp[i + 1] << endl;
}
cout << dp[N - 1] << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
using namespace std;
const long long INF = 1LL << 60;
int main(void) {
int N;
cin >> N;
vector<long long> h(N);
for (auto &x : h) {
cin >> x;
}
vector<long long> dp(N, INF);
dp[0] = 0;
for (int i = 0; i < N - 1; i++) {
dp[i + 1] = min(abs(h[i] - h[i + 1]) + dp[i], dp[i + 1]);
if (i < N - 2)
dp[i + 2] = min(abs(h[i] - h[i + 2]) + dp[i], dp[i + 2]);
// cout << dp[i + 1] << endl;
}
cout << dp[N - 1] << endl;
return 0;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 956,424 | 956,425 | u104741254 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int n, a, b, c, ar[1000005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++)
cin >> ar[i];
a = 0;
b = abs(ar[2] - ar[1]);
for (int i = 3; i <= n; i++) {
c = min(a + abs(ar[i - 2] - ar[i]), b + abs(ar[i - 1] - ar[i]));
a = b;
b = c;
}
cout << c << '\n';
} | #include <bits/stdc++.h>
using namespace std;
int n, a, b, c, ar[1000005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++)
cin >> ar[i];
a = 0;
b = c = abs(ar[2] - ar[1]);
for (int i = 3; i <= n; i++) {
c = min(a + abs(ar[i - 2] - ar[i]), b + abs(ar[i - 1] - ar[i]));
a = b;
b = c;
}
cout << c << '\n';
} | [
"assignment.change"
] | 956,426 | 956,427 | u703252117 | cpp |
p03160 | // be name khoda \\
// #define stream_enable
// #define long_enable
#define debug_enable
#include <algorithm>
#include <cmath>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <vector>
using namespace std;
#ifdef stream_enable
#define cin sss
#endif
#ifdef long_enable
typedef long long int ll;
#else
typedef int ll;
#endif
typedef pair<ll, ll> pii;
typedef vector<ll> vi;
typedef pair<ll, pii> pip;
typedef pair<pii, ll> ppi;
typedef pair<pii, pii> ppp;
typedef vector<vi> vii;
typedef vector<vii> viii;
typedef vector<bool> vb;
typedef vector<vb> vbb;
typedef vector<pii> vpii;
typedef vector<pip> vpip;
const ll MOD = 1000000007;
const long long BIG = 1446803456761533460LL;
const int Big = 336860180;
#ifdef long_enable
const ll INF = LONG_LONG_MAX;
#else
const ll INF = INT_MAX;
#endif
const ll adj4[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
const ll adj8[8][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0},
{-1, -1}, {1, -1}, {-1, 1}, {1, 1}};
#define mp make_pair
#define ff first
#define ss second
#define all(x) (x).begin(), (x).end()
#define pb push_back
#define print(x) cout << (x) << '\n'
#define print2(x, y) cout << (x) << ' ' << (y) << '\n'
#define print3(x, y, z) cout << (x) << ' ' << (y) << ' ' << (z) << '\n'
#define print4(x, y, z, t) \
cout << (x) << ' ' << (y) << ' ' << (z) << ' ' << (t) << '\n'
#define printv(x) \
fori(j12345, (x).size()) { cout << (x)[j12345] << ' '; } \
cout << '\n'
#define printvv(x) \
fori(i123456, (x).size()) { \
fori(j123456, (x)[i123456].size()) { \
cout << (x)[i123456][j123456] << ' '; \
} \
cout << '\n'; \
}
#define printp(x) cout << "(" << x.ff << ", " << x.ss << ")" << '\n'
#define printvp(x) \
fori(i1234567, (x).size()) { \
cout << "(" << x[i1234567].ff << ", " << x[i1234567].ss << ")" << '\n'; \
}
#define printa(x, n) \
fori(ja12345, n) { cout << (x)[ja12345] << ' '; } \
cout << '\n'
#define printap(x, n) \
fori(ia1234567, n) { \
cout << "(" << x[ia1234567].ff << ", " << x[ia1234567].ss << ")" << '\n'; \
}
#define printaa(x, n, m) \
fori(iaa123456, n) { \
fori(jaa123456, m) { cout << (x)[iaa123456][jaa123456] << ' '; } \
cout << '\n'; \
}
#define printav(x, n) \
fori(iaa123477, n) { printv(x[iaa123477]); }
#define printia(x, n) \
fori(ja212345, n) { cout << ja212345 << " : " << (x)[ja212345] << '\n'; }
#ifdef debug_enable
#define debug(x) \
cout << #x << " -> "; \
print(x)
#define debug2(x, y) \
cout << #x << ' ' << #y << " -> "; \
print2(x, y)
#define debug3(x, y, z) \
cout << #x << ' ' << #y << ' ' << #z << " -> "; \
print3(x, y, z)
#define debug4(x, y, z, t) \
cout << #x << ' ' << #y << ' ' << #z << ' ' << #t << " -> "; \
print4(x, y, z, t)
#define debugv(x) \
cout << #x << " -> "; \
printv(x)
#define debugvv(x) \
cout << #x << " ->\n"; \
printvv(x)
#define debugp(x) \
cout << #x << " -> "; \
printp(x)
#define debugvp(x) \
cout << #x << " ->\n"; \
printvp(x)
#define debuga(x, n) \
cout << #x << " -> "; \
printa(x, n)
#define debugap(x, n) \
cout << #x << " ->\n"; \
printap(x, n)
#define debugaa(x, n, m) \
cout << #x << " ->\n"; \
printaa(x, n, m)
#define debugav(x, n) \
cout << #x << " ->\n"; \
printav(x, n)
#define debugia(x, n) \
cout << #x << " ->\n"; \
printia(x, n)
ll clk_ar[10];
#define clk_s(i) clk_ar[i] = clock();
#define clk_e(i) \
cout << "Clock " << i << " : " \
<< (double)(clock() - clk_ar[i]) / CLOCKS_PER_SEC << " sec\n";
#else
#define debug(x)
#define debug2(x, y)
#define debug3(x, y, z)
#define debug4(x, y, z, t)
#define debugv(x)
#define debugvv(x)
#define debugp(x)
#define debugvp(x)
#define debuga(x, n)
#define debugap(x, n)
#define debugaa(x, n, m)
#define debugav(x, n, m)
#define debugia(x, n)
#define clk_s(i)
#define clk_e(i)
#endif
#define fori(i, n) for (ll i = 0; i < (n); ++i)
#define forir(i, n) for (ll i = (n)-1; i >= 0; --i)
#define forifrom(i, f, n) for (ll i = (f); i < (n); ++i)
#define forirto(i, n, f) for (ll i = (n)-1; i >= (f); --i)
#define smin(a, b) a = min(a, (b))
#define smax(a, b) a = max(a, (b))
#define inp(x) \
ll x; \
cin >> x
#define inp2(x, y) \
ll x, y; \
cin >> x >> y
#define inp3(x, y, z) \
ll x, y, z; \
cin >> x >> y >> z
#define inp4(x, y, z, w) \
ll x, y, z, w; \
cin >> x >> y >> z >> w
ll gcd(ll a, ll b) { return b == 0 ? a : gcd(b, a % b); }
ll powMod(ll a, ll b) {
ll n = 1;
ll p = a;
while (b > 0) {
if (b % 2 == 1) {
n *= p;
n %= MOD;
}
p *= p;
p %= MOD;
b /= 2;
}
return n;
}
ll modularInverse(ll a) { return powMod(a, MOD - 2); }
stringstream sss;
// -----------------------------------------------------------------------
const ll maxn = 100010;
ll ar[maxn];
ll dp[maxn];
void MAIN() {
inp(n);
fori(i, n) { cin >> ar[i]; }
memset(dp, 20, sizeof dp);
dp[0] = 0;
fori(i, n) {
smin(dp[i + 1], dp[i] + abs(ar[i] - ar[i + 1]));
smin(dp[i + 2], dp[i] + abs(ar[i] - ar[i + 2]));
}
print(dp[n]);
}
// -----------------------------------------------------------------------
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(10);
sss << R"(
)";
MAIN();
return 0;
}
| // be name khoda \\
// #define stream_enable
// #define long_enable
#define debug_enable
#include <algorithm>
#include <cmath>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <vector>
using namespace std;
#ifdef stream_enable
#define cin sss
#endif
#ifdef long_enable
typedef long long int ll;
#else
typedef int ll;
#endif
typedef pair<ll, ll> pii;
typedef vector<ll> vi;
typedef pair<ll, pii> pip;
typedef pair<pii, ll> ppi;
typedef pair<pii, pii> ppp;
typedef vector<vi> vii;
typedef vector<vii> viii;
typedef vector<bool> vb;
typedef vector<vb> vbb;
typedef vector<pii> vpii;
typedef vector<pip> vpip;
const ll MOD = 1000000007;
const long long BIG = 1446803456761533460LL;
const int Big = 336860180;
#ifdef long_enable
const ll INF = LONG_LONG_MAX;
#else
const ll INF = INT_MAX;
#endif
const ll adj4[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
const ll adj8[8][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0},
{-1, -1}, {1, -1}, {-1, 1}, {1, 1}};
#define mp make_pair
#define ff first
#define ss second
#define all(x) (x).begin(), (x).end()
#define pb push_back
#define print(x) cout << (x) << '\n'
#define print2(x, y) cout << (x) << ' ' << (y) << '\n'
#define print3(x, y, z) cout << (x) << ' ' << (y) << ' ' << (z) << '\n'
#define print4(x, y, z, t) \
cout << (x) << ' ' << (y) << ' ' << (z) << ' ' << (t) << '\n'
#define printv(x) \
fori(j12345, (x).size()) { cout << (x)[j12345] << ' '; } \
cout << '\n'
#define printvv(x) \
fori(i123456, (x).size()) { \
fori(j123456, (x)[i123456].size()) { \
cout << (x)[i123456][j123456] << ' '; \
} \
cout << '\n'; \
}
#define printp(x) cout << "(" << x.ff << ", " << x.ss << ")" << '\n'
#define printvp(x) \
fori(i1234567, (x).size()) { \
cout << "(" << x[i1234567].ff << ", " << x[i1234567].ss << ")" << '\n'; \
}
#define printa(x, n) \
fori(ja12345, n) { cout << (x)[ja12345] << ' '; } \
cout << '\n'
#define printap(x, n) \
fori(ia1234567, n) { \
cout << "(" << x[ia1234567].ff << ", " << x[ia1234567].ss << ")" << '\n'; \
}
#define printaa(x, n, m) \
fori(iaa123456, n) { \
fori(jaa123456, m) { cout << (x)[iaa123456][jaa123456] << ' '; } \
cout << '\n'; \
}
#define printav(x, n) \
fori(iaa123477, n) { printv(x[iaa123477]); }
#define printia(x, n) \
fori(ja212345, n) { cout << ja212345 << " : " << (x)[ja212345] << '\n'; }
#ifdef debug_enable
#define debug(x) \
cout << #x << " -> "; \
print(x)
#define debug2(x, y) \
cout << #x << ' ' << #y << " -> "; \
print2(x, y)
#define debug3(x, y, z) \
cout << #x << ' ' << #y << ' ' << #z << " -> "; \
print3(x, y, z)
#define debug4(x, y, z, t) \
cout << #x << ' ' << #y << ' ' << #z << ' ' << #t << " -> "; \
print4(x, y, z, t)
#define debugv(x) \
cout << #x << " -> "; \
printv(x)
#define debugvv(x) \
cout << #x << " ->\n"; \
printvv(x)
#define debugp(x) \
cout << #x << " -> "; \
printp(x)
#define debugvp(x) \
cout << #x << " ->\n"; \
printvp(x)
#define debuga(x, n) \
cout << #x << " -> "; \
printa(x, n)
#define debugap(x, n) \
cout << #x << " ->\n"; \
printap(x, n)
#define debugaa(x, n, m) \
cout << #x << " ->\n"; \
printaa(x, n, m)
#define debugav(x, n) \
cout << #x << " ->\n"; \
printav(x, n)
#define debugia(x, n) \
cout << #x << " ->\n"; \
printia(x, n)
ll clk_ar[10];
#define clk_s(i) clk_ar[i] = clock();
#define clk_e(i) \
cout << "Clock " << i << " : " \
<< (double)(clock() - clk_ar[i]) / CLOCKS_PER_SEC << " sec\n";
#else
#define debug(x)
#define debug2(x, y)
#define debug3(x, y, z)
#define debug4(x, y, z, t)
#define debugv(x)
#define debugvv(x)
#define debugp(x)
#define debugvp(x)
#define debuga(x, n)
#define debugap(x, n)
#define debugaa(x, n, m)
#define debugav(x, n, m)
#define debugia(x, n)
#define clk_s(i)
#define clk_e(i)
#endif
#define fori(i, n) for (ll i = 0; i < (n); ++i)
#define forir(i, n) for (ll i = (n)-1; i >= 0; --i)
#define forifrom(i, f, n) for (ll i = (f); i < (n); ++i)
#define forirto(i, n, f) for (ll i = (n)-1; i >= (f); --i)
#define smin(a, b) a = min(a, (b))
#define smax(a, b) a = max(a, (b))
#define inp(x) \
ll x; \
cin >> x
#define inp2(x, y) \
ll x, y; \
cin >> x >> y
#define inp3(x, y, z) \
ll x, y, z; \
cin >> x >> y >> z
#define inp4(x, y, z, w) \
ll x, y, z, w; \
cin >> x >> y >> z >> w
ll gcd(ll a, ll b) { return b == 0 ? a : gcd(b, a % b); }
ll powMod(ll a, ll b) {
ll n = 1;
ll p = a;
while (b > 0) {
if (b % 2 == 1) {
n *= p;
n %= MOD;
}
p *= p;
p %= MOD;
b /= 2;
}
return n;
}
ll modularInverse(ll a) { return powMod(a, MOD - 2); }
stringstream sss;
// -----------------------------------------------------------------------
const ll maxn = 100010;
ll ar[maxn];
ll dp[maxn];
void MAIN() {
inp(n);
fori(i, n) { cin >> ar[i]; }
memset(dp, 60, sizeof dp);
dp[0] = 0;
fori(i, n) {
smin(dp[i + 1], dp[i] + abs(ar[i] - ar[i + 1]));
smin(dp[i + 2], dp[i] + abs(ar[i] - ar[i + 2]));
}
print(dp[n - 1]);
}
// -----------------------------------------------------------------------
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(10);
sss << R"(
)";
MAIN();
return 0;
}
| [
"literal.number.change",
"call.arguments.change"
] | 956,436 | 956,435 | u780597450 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
int dp[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
dp[0] = 0;
dp[1] = fabs(arr[1] - arr[0]);
for (int i = 2; i < n; i++) {
dp[i] = min(dp[i - 1] + fabs(arr[i] - arr[i - 1]),
dp[i - 2] + fabs(arr[i] - arr[i - 2]));
}
cout << dp[n];
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
int dp[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
dp[0] = 0;
dp[1] = fabs(arr[1] - arr[0]);
for (int i = 2; i < n; i++) {
dp[i] = min(dp[i - 1] + fabs(arr[i] - arr[i - 1]),
dp[i - 2] + fabs(arr[i] - arr[i - 2]));
}
cout << dp[n - 1];
return 0;
}
| [
"expression.operation.binary.add"
] | 956,438 | 956,439 | u236295472 | cpp |
p03160 | #include <algorithm>
#include <cmath>
#include <cstdio>
using namespace std;
int n, a[100005], dp[100005];
int main() {
a[0] = 1000000000;
scanf("%d%d", &n, &a[1]);
for (int i = 2; i <= n; i++) {
scanf("%d", &a[i]);
dp[i] = dp[i - 1] + abs(a[i] - a[i - 1]);
dp[i] = max(dp[i], dp[i - 2] + abs(a[i] - a[i - 2]));
}
printf("%d\n", dp[n]);
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
using namespace std;
int n, a[100005], dp[100005];
int main() {
a[0] = 1000000000;
scanf("%d%d", &n, &a[1]);
for (int i = 2; i <= n; i++) {
scanf("%d", &a[i]);
dp[i] = dp[i - 1] + abs(a[i] - a[i - 1]);
dp[i] = min(dp[i], dp[i - 2] + abs(a[i] - a[i - 2]));
}
printf("%d\n", dp[n]);
return 0;
}
| [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 956,445 | 956,446 | u287687156 | cpp |
p03160 | #include "bits/stdc++.h"
using namespace std;
int main() {
int n;
// freopen("input.txt","r",stdin);
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
if (n == 1) {
cout << 0 << endl;
return 0;
}
return 0;
vector<int> dp(n);
dp[0] = 0;
dp[1] = abs(v[1] - v[0]);
for (int i = 2; i < n; i++) {
int x = dp[i - 1] + abs(v[i - 1] - v[i]);
int y = dp[i - 2] + abs(v[i] - v[i - 2]);
dp[i] = min(x, y);
}
cout << dp[n - 1] << endl;
return 0;
} | #include "bits/stdc++.h"
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
if (n == 1) {
cout << 0 << endl;
return 0;
}
vector<int> dp(n);
dp[0] = 0;
dp[1] = abs(v[1] - v[0]);
for (int i = 2; i < n; i++) {
int x = dp[i - 1] + abs(v[i - 1] - v[i]);
int y = dp[i - 2] + abs(v[i] - v[i - 2]);
dp[i] = min(x, y);
}
cout << dp[n - 1] << endl;
return 0;
} | [] | 956,449 | 956,450 | u877939361 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n), dp(n);
for (int i = 0; i < n; i++)
cin >> v[i];
dp[0] = 0;
for (int i = 1; i <= n; i++)
dp[i] = INT_MAX;
for (int i = 0; i < n; i++) {
if (i + 1 < n)
dp[i + 1] = min(dp[i + 1], dp[i] + abs(v[i] - v[i + 1]));
if (i + 2 < n)
dp[i + 2] = min(dp[i + 2], dp[i] + abs(v[i] - v[i + 2]));
}
cout << dp[n - 1] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n), dp(n + 1);
for (int i = 0; i < n; i++)
cin >> v[i];
dp[0] = 0;
for (int i = 1; i <= n; i++)
dp[i] = INT_MAX;
for (int i = 0; i < n; i++) {
if (i + 1 < n)
dp[i + 1] = min(dp[i + 1], dp[i] + abs(v[i] - v[i + 1]));
if (i + 2 < n)
dp[i + 2] = min(dp[i + 2], dp[i] + abs(v[i] - v[i + 2]));
}
cout << dp[n - 1] << endl;
return 0;
}
| [
"assignment.change"
] | 956,455 | 956,456 | u906572139 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
int N, H[101010], dp[101010];
int main() {
cin >> N;
rep(i, N) { cin >> H[i]; }
rep(i, N) { dp[i] = 100000; }
dp[0] = 0;
for (int i = 0; i < N; ++i) {
dp[i + 1] = min(dp[i + 1], dp[i] + abs(H[i] - H[i + 1]));
dp[i + 2] = min(dp[i + 2], dp[i] + abs(H[i] - H[i + 2]));
}
cout << dp[N - 1] << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
int N, H[101010], dp[101010];
int main() {
cin >> N;
rep(i, N) { cin >> H[i]; }
rep(i, N) { dp[i] = INFINITY; }
dp[0] = 0;
for (int i = 0; i < N; ++i) {
dp[i + 1] = min(dp[i + 1], dp[i] + abs(H[i] - H[i + 1]));
dp[i + 2] = min(dp[i + 2], dp[i] + abs(H[i] - H[i + 2]));
}
cout << dp[N - 1] << endl;
} | [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 956,457 | 956,458 | u653388379 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
int N, H[101010], dp[101010];
int main() {
cin >> N;
rep(i, N) { cin >> H[i]; }
rep(i, N) { dp[i] = 1000000; }
dp[0] = 0;
for (int i = 0; i < N; ++i) {
dp[i + 1] = min(dp[i + 1], dp[i] + abs(H[i] - H[i + 1]));
dp[i + 2] = min(dp[i + 2], dp[i] + abs(H[i] - H[i + 2]));
}
cout << dp[N - 1] << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
int N, H[101010], dp[101010];
int main() {
cin >> N;
rep(i, N) { cin >> H[i]; }
rep(i, N) { dp[i] = INFINITY; }
dp[0] = 0;
for (int i = 0; i < N; ++i) {
dp[i + 1] = min(dp[i + 1], dp[i] + abs(H[i] - H[i + 1]));
dp[i + 2] = min(dp[i + 2], dp[i] + abs(H[i] - H[i + 2]));
}
cout << dp[N - 1] << endl;
} | [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 956,459 | 956,458 | u653388379 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
vector<int> vec;
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
vec.push_back(x);
}
vector<int> dp;
dp.push_back(0);
dp.push_back(abs(vec[0] - vec[1]));
for (int i = 2; i < n; i++) {
int y = min(abs(vec[i - 1] - vec[i]) + dp[i - 1],
abs(vec[i - 2] - vec[i]) + dp[i - 2]);
dp.push_back(y);
}
return dp[n - 1];
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
vector<int> vec;
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
vec.push_back(x);
}
vector<int> dp;
dp.push_back(0);
dp.push_back(abs(vec[0] - vec[1]));
for (int i = 2; i < n; i++) {
int y = min(abs(vec[i - 1] - vec[i]) + dp[i - 1],
abs(vec[i - 2] - vec[i]) + dp[i - 2]);
dp.push_back(y);
}
cout << dp[n - 1];
return 0;
} | [
"io.output.change",
"control_flow.return.add",
"control_flow.return.0.add"
] | 956,474 | 956,475 | u425363136 | cpp |
p03160 | #include <iostream>
#include <vector>
using namespace std;
#define M_C 10e5
int main() {
vector<int> D(M_C, INT8_MAX);
D[0] = 0;
vector<int> H(M_C);
int N;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> H[i];
}
for (int i = 0; i < N - 1; i++) {
D[i + 1] = min(D[i + 1], D[i] + abs(H[i] - H[i + 1]));
if (i + 2 < N)
D[i + 2] = min(D[i + 2], D[i] + abs(H[i] - H[i + 2]));
}
cout << D[N - 1] << endl;
} | #include <iostream>
#include <vector>
using namespace std;
#define M_C 10e5
int main() {
vector<int> D(M_C, INT32_MAX);
D[0] = 0;
vector<int> H(M_C);
int N;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> H[i];
}
for (int i = 0; i < N - 1; i++) {
D[i + 1] = min(D[i + 1], D[i] + abs(H[i] - H[i + 1]));
if (i + 2 < N)
D[i + 2] = min(D[i + 2], D[i] + abs(H[i] - H[i + 2]));
}
cout << D[N - 1] << endl;
} | [] | 956,486 | 956,487 | u088864946 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int n, a[100005];
int dp[100005][3];
int rec(int i = 0, int pos = 0) {
if (i >= n)
return LONG_MAX;
if (i == n - 1)
return abs(a[i] - a[i - pos]);
if (dp[i][pos] + 1)
return dp[i][pos];
ll one = rec(i + 1, 1);
ll two = rec(i + 2, 2);
return dp[i][pos] = min(one, two) + abs(a[i] - a[i - pos]);
}
int main() {
memset(dp, -1, sizeof(dp));
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i];
cout << rec();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
int n, a[100005];
ll dp[100005][3];
ll rec(int i = 0, int pos = 0) {
if (i >= n)
return LONG_MAX;
if (i == n - 1)
return abs(a[i] - a[i - pos]);
if (dp[i][pos] + 1)
return dp[i][pos];
ll one = rec(i + 1, 1);
ll two = rec(i + 2, 2);
return dp[i][pos] = min(one, two) + abs(a[i] - a[i - pos]);
}
int main() {
memset(dp, -1, sizeof(dp));
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i];
cout << rec();
return 0;
}
| [
"variable_declaration.type.change"
] | 956,488 | 956,489 | u840404068 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
int a[N];
int dp[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
dp[n - 1] = 0;
dp[n - 2] = abs(a[n - 2] - a[n - 1]);
for (int i = n - 3; i >= 0; i--) {
dp[i] =
min(dp[i + 1] + abs(a[i] - a[i + 1]), dp[i + 2] + abs(a[i] - a[i - 2]));
}
cout << dp[0] << "\n";
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
int a[N];
int dp[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
dp[n - 1] = 0;
dp[n - 2] = abs(a[n - 2] - a[n - 1]);
for (int i = n - 3; i >= 0; i--) {
dp[i] =
min(dp[i + 1] + abs(a[i] - a[i + 1]), dp[i + 2] + abs(a[i] - a[i + 2]));
}
cout << dp[0] << "\n";
return 0;
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 956,494 | 956,495 | u886414021 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int N;
int h[10001];
cin >> N;
for (int i = 0; i < N; i++) {
cin >> h[i];
}
int dp[10001] = {100000000};
dp[1] = abs(h[1] - h[0]);
for (int 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 - 1] << endl;
// system("pause");
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int N;
int h[100001];
cin >> N;
for (int i = 0; i < N; i++) {
cin >> h[i];
}
ll dp[100001] = {0};
dp[1] = abs(h[1] - h[0]);
for (int 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 - 1] << endl;
// system("pause");
return 0;
} | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"variable_declaration.type.change"
] | 956,512 | 956,510 | u913836622 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
vector<int> height(n);
for (int i = 0; i < n; i++)
cin >> height[i];
vector<int> answer(n, 0);
if (n > 1) {
answer[1] = abs(height[1] - height[0]);
for (int i = 2; i < n; i++)
answer[i] = max(abs(height[i] - height[i - 1]) + answer[i - 1],
abs(height[i] - height[i - 2]) + answer[i - 2]);
}
cout << answer[n - 1];
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
vector<int> height(n);
for (int i = 0; i < n; i++)
cin >> height[i];
vector<int> answer(n, 0);
if (n > 1) {
answer[1] = abs(height[1] - height[0]);
for (int i = 2; i < n; i++)
answer[i] = min(abs(height[i] - height[i - 1]) + answer[i - 1],
abs(height[i] - height[i - 2]) + answer[i - 2]);
}
cout << answer[n - 1];
return 0;
}
| [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 956,541 | 956,542 | u667099228 | cpp |
p03160 | #include <cmath>
#include <iostream>
using namespace std;
const int MAXN = (int)1e5 + 5;
int h[MAXN];
int f[MAXN];
void solve(int n) {
f[1] = 0;
f[2] = abs(h[2] - h[1]);
for (int i = 2; i <= n; ++i) {
f[i] =
min(f[i - 1] + abs(h[i - 1] - h[i]), f[i - 2] + abs(h[i - 2] - h[i]));
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", h + i);
}
solve(n);
printf("%d\n", f[n]);
return 0;
}
| #include <cmath>
#include <iostream>
using namespace std;
const int MAXN = (int)1e5 + 5;
int h[MAXN];
int f[MAXN];
void solve(int n) {
f[1] = 0;
f[2] = abs(h[2] - h[1]);
for (int i = 3; i <= n; ++i) {
f[i] =
min(f[i - 1] + abs(h[i - 1] - h[i]), f[i - 2] + abs(h[i - 2] - h[i]));
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", h + i);
}
solve(n);
printf("%d\n", f[n]);
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 956,545 | 956,546 | u074059053 | cpp |
p03160 | #include <bits/stdc++.h>
#define f(i, a, b) for (int i = a; i < b; i++)
using namespace std;
typedef long long int ll;
typedef long double ld;
int h[100010], dp[100010];
int main() {
int n;
cin >> n;
f(i, 0, n) cin >> h[i];
dp[1] = h[1] - h[0];
f(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];
} | #include <bits/stdc++.h>
#define f(i, a, b) for (int i = a; i < b; i++)
using namespace std;
typedef long long int ll;
typedef long double ld;
int h[100010], dp[100010];
int main() {
int n;
cin >> n;
f(i, 0, n) cin >> h[i];
dp[1] = abs(h[1] - h[0]);
f(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];
} | [
"call.add",
"call.arguments.change"
] | 956,547 | 956,548 | u834353617 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define fastio \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define endl '\n'
#define ll long long
#define inf 1000000007
int main() {
fastio;
#ifndef ONLINE_JUDGE
freopen("input.txt", "rt", stdin);
freopen("output.txt", "wt", stdout);
#endif
ll n;
cin >> n;
ll arr[n];
ll dp[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] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define fastio \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define endl '\n'
#define ll long long
#define inf 1000000007
int main() {
fastio;
#ifdef APNA_IO
freopen("input.txt", "rt", stdin);
freopen("output.txt", "wt", stdout);
#endif
ll n;
cin >> n;
ll arr[n];
ll dp[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] << endl;
return 0;
}
| [] | 956,549 | 956,550 | u669461113 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define MAXN 100500
int a[MAXN];
int ans[MAXN];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
ans[0] = a[0];
ans[1] = abs(a[1] - a[0]);
for (int i = 2; i < n; i++) {
ans[i] = min(ans[i - 1] + abs(a[i - 1] - a[i]),
ans[i - 2] + abs(a[i - 2] - a[i]));
}
cout << ans[n - 1];
} | #include <bits/stdc++.h>
using namespace std;
#define MAXN 100500
int a[MAXN];
int ans[MAXN];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
ans[0] = 0;
ans[1] = abs(a[1] - a[0]);
for (int i = 2; i < n; i++) {
ans[i] = min(ans[i - 1] + abs(a[i - 1] - a[i]),
ans[i - 2] + abs(a[i - 2] - a[i]));
}
cout << ans[n - 1];
} | [] | 956,555 | 956,556 | u312372815 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n);
int i, j;
for (i = 0; i < n; i++) {
cin >> v[i];
}
vector<int> ans(n, 0);
ans[0] = 0;
ans[1] = abs(v[1] - v[0]);
for (i = 2; i < n; i++) {
ans[i] = min(ans[i - 1] + abs(v[i] - ans[i - 1]),
ans[i - 2] + abs(v[i] - v[i - 2]));
}
cout << ans[n - 1];
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n);
int i, j;
for (i = 0; i < n; i++) {
cin >> v[i];
}
vector<int> ans(n, 0);
ans[0] = 0;
ans[1] = abs(v[1] - v[0]);
for (i = 2; i < n; i++) {
ans[i] = min(ans[i - 1] + abs(v[i] - v[i - 1]),
ans[i - 2] + abs(v[i] - v[i - 2]));
}
cout << ans[n - 1];
} | [
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 956,560 | 956,561 | u528153468 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, i;
cin >> n;
long long int a[n + 10];
long long int ans[n + 10];
for (i = 1; i <= n; i++) {
cin >> a[i];
}
ans[1] = a[1];
ans[2] = abs(a[2] - a[1]);
for (i = 3; i <= n; i++) {
ans[i] = min(ans[i - 1] + abs(a[i] - a[i - 1]),
ans[i - 2] + abs(a[i] - a[i - 2]));
}
cout << ans[n] << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, i;
cin >> n;
long long int a[n + 10];
long long int ans[n + 10];
for (i = 1; i <= n; i++) {
cin >> a[i];
}
ans[1] = 0;
ans[2] = abs(a[2] - a[1]);
for (i = 3; i <= n; i++) {
ans[i] = min(ans[i - 1] + abs(a[i] - a[i - 1]),
ans[i - 2] + abs(a[i] - a[i - 2]));
// cout<<ans[i]<<endl;
}
// cout<<endl;
cout << ans[n] << endl;
} | [
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add"
] | 956,564 | 956,565 | u292039930 | cpp |
p03160 | #include <bits/stdc++.h>
#define MAX 100010
using namespace std;
typedef long long ll;
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
int H[n];
for (int i = 0; i < n; i++) {
cin >> H[i];
}
int dp[n];
for (int i = 0; i < n; i++)
dp[i] = 1000000100;
dp[0] = 0;
for (int i = 0; i < n - 1; i++) {
int j = i + 1;
dp[j] = min(dp[j], dp[i] + abs(H[i] - H[j]));
if (j + 1 < n) {
dp[j + 1] = min(dp[j + 1], dp[i] + abs(H[i] - H[j]));
}
}
cout << dp[n - 1] << "\n";
return 0;
} | #include <bits/stdc++.h>
#define MAX 100010
using namespace std;
typedef long long ll;
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
int H[n];
for (int i = 0; i < n; i++) {
cin >> H[i];
}
int dp[n];
for (int i = 0; i < n; i++)
dp[i] = 1000000100;
dp[0] = 0;
for (int i = 0; i < n - 1; i++) {
int j = i + 1;
dp[j] = min(dp[j], dp[i] + abs(H[i] - H[j]));
if (j + 1 < n) {
dp[j + 1] = min(dp[j + 1], dp[i] + abs(H[i] - H[j + 1]));
}
}
cout << dp[n - 1] << "\n";
return 0;
} | [] | 956,570 | 956,571 | u298874306 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
long long int f(int *h, int i) {
if (i <= 0)
return 0;
if (i == 1)
return abs(h[i] - h[0]);
long long int ans1 = f(h, i - 2) + abs(h[i] - h[i - 2]);
long long int ans2 = f(h, i - 1) + abs(h[i] - h[i - 1]);
return min(ans1, ans2);
}
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
// cout<<f(a,n-1);
long long 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 - 1] + abs(a[i] - a[i - 1]), dp[i - 2] + a[i] - a[i - 2]);
cout << dp[n - 1];
}
| #include <bits/stdc++.h>
using namespace std;
long long int f(int *h, int i) {
if (i <= 0)
return 0;
if (i == 1)
return abs(h[i] - h[0]);
long long int ans1 = f(h, i - 2) + abs(h[i] - h[i - 2]);
long long int ans2 = f(h, i - 1) + abs(h[i] - h[i - 1]);
return min(ans1, ans2);
}
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
// cout<<f(a,n-1);
long long 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 - 1] + abs(a[i] - a[i - 1]), dp[i - 2] + abs(a[i] - a[i - 2]));
cout << dp[n - 1];
}
| [
"call.add",
"call.arguments.change"
] | 956,572 | 956,573 | u993625154 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
long long int f(int *h, int i) {
if (i <= 0)
return 0;
if (i == 1)
return abs(h[i] - h[0]);
long long int ans1 = f(h, i - 2) + abs(h[i] - h[i - 2]);
long long int ans2 = f(h, i - 1) + abs(h[i] - h[i - 1]);
return min(ans1, ans2);
}
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
// cout<<f(a,n-1);
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 - 1] + abs(a[i] - a[i - 1]), dp[i - 2] + a[i] - a[i - 2]);
cout << dp[n - 1];
}
| #include <bits/stdc++.h>
using namespace std;
long long int f(int *h, int i) {
if (i <= 0)
return 0;
if (i == 1)
return abs(h[i] - h[0]);
long long int ans1 = f(h, i - 2) + abs(h[i] - h[i - 2]);
long long int ans2 = f(h, i - 1) + abs(h[i] - h[i - 1]);
return min(ans1, ans2);
}
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
// cout<<f(a,n-1);
long long 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 - 1] + abs(a[i] - a[i - 1]), dp[i - 2] + abs(a[i] - a[i - 2]));
cout << dp[n - 1];
}
| [
"variable_declaration.type.widen.change",
"call.add",
"call.arguments.change"
] | 956,574 | 956,573 | u993625154 | cpp |
p03160 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
int dp[100005];
int a[100005];
int wb(int x, int y) {
int k = x - y;
if (k >= 0)
return k;
else
return -k;
}
int main() {
int N;
cin >> N;
for (int i = 1; i <= N; i++) {
cin >> a[i];
}
dp[1] = 0;
dp[2] = wb(a[1], a[2]);
for (int i = 2; i <= N; i++) {
if (dp[i - 1] + wb(a[i], a[i - 1]) < dp[i - 2] + wb(a[i], a[i - 2]))
dp[i] = dp[i - 1] + wb(a[i], a[i - 1]);
else
dp[i] = dp[i - 2] + wb(a[i], a[i - 2]);
}
cout << dp[N];
return 0;
}
| #include <bits/stdc++.h>
#include <iostream>
using namespace std;
int dp[100005];
int a[100005];
int wb(int x, int y) {
int k = x - y;
if (k >= 0)
return k;
else
return -k;
}
int main() {
int N;
cin >> N;
for (int i = 1; i <= N; i++) {
cin >> a[i];
}
dp[1] = 0;
dp[2] = wb(a[1], a[2]);
for (int i = 3; i <= N; i++) {
if (dp[i - 1] + wb(a[i], a[i - 1]) < dp[i - 2] + wb(a[i], a[i - 2]))
dp[i] = dp[i - 1] + wb(a[i], a[i - 1]);
else
dp[i] = dp[i - 2] + wb(a[i], a[i - 2]);
}
cout << dp[N];
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 956,575 | 956,576 | u365054905 | cpp |
p03160 | #include <algorithm>
#include <iostream>
int main() {
int N;
std::cin >> N;
int h[N], dp[N];
for (int i = 0; i < N; i++) {
std::cin >> h[i];
}
dp[0] = 0;
dp[1] = h[1] - h[0];
for (int i = 2; i < N; i++) {
dp[i] = std::min(dp[i - 2] + abs(h[i] - h[i - 2]),
dp[i - 1] + abs(h[i] - h[i - 1]));
}
std::cout << dp[N - 1] << std::endl;
} | #include <algorithm>
#include <iostream>
int main() {
int N;
std::cin >> N;
int h[N], dp[N];
for (int i = 0; i < N; i++) {
std::cin >> h[i];
}
dp[0] = 0;
dp[1] = abs(h[1] - h[0]);
for (int i = 2; i < N; i++) {
dp[i] = std::min(dp[i - 2] + abs(h[i] - h[i - 2]),
dp[i - 1] + abs(h[i] - h[i - 1]));
}
std::cout << dp[N - 1] << std::endl;
} | [
"call.add",
"call.arguments.change"
] | 956,577 | 956,578 | u287990715 | cpp |
p03160 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <limits>
#include <tuple>
#include <vector>
using namespace std;
#define REP(var, num) for (sll var = 0; var < num; var++)
typedef signed long long sll;
typedef unsigned long long ull;
int main() {
sll n;
cin >> n;
vector<sll> hs(n);
vector<sll> dp(n);
REP(i, n) { cin >> hs[i]; }
REP(i, n) {
if (i == 0) {
dp[i] = 0;
} else if (i == 1) {
dp[i] = hs[1] - hs[0];
} else {
dp[i] = min(abs(hs[i] - hs[i - 1]) + dp[i - 1],
abs(hs[i] - hs[i - 2]) + dp[i - 2]);
}
}
cout << dp[n - 1] << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <limits>
#include <tuple>
#include <vector>
using namespace std;
#define REP(var, num) for (sll var = 0; var < num; var++)
typedef signed long long sll;
typedef unsigned long long ull;
int main() {
sll n;
cin >> n;
vector<sll> hs(n);
vector<sll> dp(n);
REP(i, n) { cin >> hs[i]; }
REP(i, n) {
if (i == 0) {
dp[i] = 0;
} else if (i == 1) {
dp[i] = abs(hs[1] - hs[0]);
} else {
dp[i] = min(abs(hs[i] - hs[i - 1]) + dp[i - 1],
abs(hs[i] - hs[i - 2]) + dp[i - 2]);
}
}
cout << dp[n - 1] << endl;
return 0;
} | [
"call.add",
"call.arguments.change"
] | 956,595 | 956,596 | u544156685 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int n, h[100005];
int dp[100005];
int jump(int i) {
if (i >= n - 1)
return 0;
if (dp[i] != -1)
return dp[i];
int p = abs(h[i] - h[i + 1]) + jump(i + 1);
int q = n - i >= 2 ? abs(h[i] - h[i + 2]) + jump(i + 2) : INT_MAX;
return dp[i] = min(p, q);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; ++i)
cin >> h[i];
memset(dp, -1, sizeof dp);
cout << jump(0) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int n, h[100005];
int dp[100005];
int jump(int i) {
if (i >= n)
return 0;
if (dp[i] != -1)
return dp[i];
int p = abs(h[i] - h[i + 1]) + jump(i + 1);
int q = n - i >= 2 ? abs(h[i] - h[i + 2]) + jump(i + 2) : INT_MAX;
return dp[i] = min(p, q);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i)
cin >> h[i];
memset(dp, -1, sizeof dp);
cout << jump(1) << endl;
return 0;
}
| [
"expression.operation.binary.remove",
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"io.output.ch... | 956,600 | 956,601 | u221386183 | cpp |
p03160 | // https://atcoder.jp/contests/dp/tasks/dp_a
#include <bits/stdc++.h>
using namespace std;
const int NAX = int(1e5) + 5;
int arr[NAX];
int dp[NAX];
int N;
int solve(int i) {
if (i >= N)
return 0;
if (dp[i] != -1)
return dp[i];
int a = abs(arr[i] - arr[i + 1]) + solve(i + 1);
int b = N - i >= 2 ? abs(arr[i] - arr[i + 2]) + solve(i + 2) : 0;
return dp[i] = min(a, b);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
memset(dp, -1, sizeof(dp));
cin >> N;
for (int i = 1; i <= N; ++i)
cin >> arr[i];
cout << solve(1) << endl;
return 0;
}
| // https://atcoder.jp/contests/dp/tasks/dp_a
#include <bits/stdc++.h>
using namespace std;
const int NAX = int(1e5) + 5;
int arr[NAX];
int dp[NAX];
int N;
int solve(int i) {
if (i >= N)
return 0;
if (dp[i] != -1)
return dp[i];
int a = abs(arr[i] - arr[i + 1]) + solve(i + 1);
int b = N - i >= 2 ? abs(arr[i] - arr[i + 2]) + solve(i + 2) : INT_MAX;
return dp[i] = min(a, b);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
memset(dp, -1, sizeof(dp));
cin >> N;
for (int i = 1; i <= N; ++i)
cin >> arr[i];
cout << solve(1) << endl;
return 0;
}
| [
"identifier.replace.add",
"literal.replace.remove"
] | 956,602 | 956,603 | u221386183 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.