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 8
values |
|---|---|---|---|---|---|---|---|
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 c[n] = {0};
c[1] = h[1] - h[0];
for (int i = 2; i < n; i++) {
c[i] =
min(c[i - 1] + abs(h[i] - h[i - 1]), c[i - 2] + abs(h[i] - h[i - 2]));
}
cout <<... | #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 c[n] = {0};
c[1] = abs(h[1] - h[0]);
for (int i = 2; i < n; i++) {
c[i] =
min(c[i - 1] + abs(h[i] - h[i - 1]), c[i - 2] + abs(h[i] - h[i - 2]));
}
co... | [
"call.add",
"call.arguments.change"
] | 955,213 | 955,214 | u107193447 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int n;
int a[1000009], dp[1000009];
int main() {
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i];
dp[0] = 0;
dp[1] = abs(a[1] - a[0]);
for (int i = 1; i < n; i++) {
dp[i] =
min(dp[i - 2] + abs(a[i] - a[i - 2]), dp[i - 1] + abs(a[i] - a[i - 1]))... | #include <bits/stdc++.h>
using namespace std;
int n;
int a[1000009], dp[1000009];
int main() {
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i];
dp[0] = 0;
dp[1] = abs(a[1] - a[0]);
for (int i = 2; i < n; i++) {
dp[i] =
min(dp[i - 2] + abs(a[i] - a[i - 2]), dp[i - 1] + abs(a[i] - a[i - 1]))... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 955,217 | 955,218 | u096956975 | cpp |
p03160 | /////////////////////////////////////////////////////////////////////////////////
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$' `$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$//
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$' `$$$$$$$$$$$$$$$$$$$$$$$$$$$$//
//$$$'`$$$$$$$$$$$$$'`$$$$$$! !$$$$$$'`$$$$$$$$$$$$$'`$$$//
//$$$$ $$$$$$$$$$$ $$$$$$$ ... | /////////////////////////////////////////////////////////////////////////////////
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$' `$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$//
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$' `$$$$$$$$$$$$$$$$$$$$$$$$$$$$//
//$$$'`$$$$$$$$$$$$$'`$$$$$$! !$$$$$$'`$$$$$$$$$$$$$'`$$$//
//$$$$ $$$$$$$$$$$ $$$$$$$ ... | [
"assignment.change",
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add"
] | 955,222 | 955,223 | u758887062 | cpp |
p03160 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
const int INF = 1e5 + 9;
int main() {
int n;
scanf("%d", &n);
vector<int> v(n);
for (int &x : v)
scanf("%d", &x);
vector<int> dp(n, INF);
dp[0] = 0;
for (int i = 0; i < n; ++i) {
for (int j : {i + 1, i + 2}) {
if (j < n)
... | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
const int INF = 1e9 + 5;
int main() {
int n;
scanf("%d", &n);
vector<int> v(n);
for (int &x : v)
scanf("%d", &x);
vector<int> dp(n, INF);
dp[0] = 0;
for (int i = 0; i < n; ++i) {
for (int j : {i + 1, i + 2}) {
if (j < n)
... | [
"literal.number.change",
"expression.operation.binary.change"
] | 955,224 | 955,225 | u753187241 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> VL;
typedef vector<pair<ll, ll>> VPI;
typedef pair<ll, ll> PLL;
typedef map<ll, ll> MLL;
#define EPS 1e-9
#define pb push_back
#define FOR(i, a, b) for (ll i = a; i < b; i++)
#define PI 3.1415926535897932384626433832795
#define MOD 1... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> VL;
typedef vector<pair<ll, ll>> VPI;
typedef pair<ll, ll> PLL;
typedef map<ll, ll> MLL;
#define EPS 1e-9
#define pb push_back
#define FOR(i, a, b) for (ll i = a; i < b; i++)
#define PI 3.1415926535897932384626433832795
#define MOD 1... | [
"call.add",
"call.arguments.change"
] | 955,226 | 955,227 | u019415633 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int h[n + 2000];
long long cs[n + 20];
for (int i = 1; i <= n; i++)
cin >> h[i];
cs[0] = 0;
cs[1] = 0;
cs[2] = abs(h[2] - h[1]);
for (int i = 3; i <= n; i++)
cs[i] =
min(cs[i - 2] + abs(h[i] - h[i - 2]), cs[i -... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int h[n + 2000];
long long cs[n + 20];
for (int i = 1; i <= n; i++)
cin >> h[i];
cs[0] = 0;
cs[1] = 0;
cs[2] = abs(h[2] - h[1]);
for (int i = 3; i <= n; i++)
cs[i] =
min(cs[i - 2] + abs(h[i] - h[i - 2]), cs[i -... | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 955,230 | 955,231 | u383252618 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int jp[n + 1], h[n + 1];
for (int i = 1; i <= n; i++) {
cin >> h[i];
}
h[0] = 0;
jp[0] = 0;
jp[1] = 0;
for (int i = 2; i <= n; i++) {
jp[i] = min((abs(h[i] - h[i - 1]) + jp[i - 1]),
(abs(h[i] - h[i - 2]... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int jp[n + 1], h[n + 1];
for (int i = 1; i <= n; i++) {
cin >> h[i];
}
h[0] = 10000000;
jp[0] = 0;
jp[1] = 0;
for (int i = 2; i <= n; i++) {
jp[i] = min((abs(h[i] - h[i - 1]) + jp[i - 1]),
(abs(h[i] - h... | [
"literal.number.change",
"assignment.value.change"
] | 955,237 | 955,238 | u403935967 | cpp |
p03160 | #include <bits/stdc++.h>
#define rep(i, a, b) for (int i = a; i < b; i++)
using namespace std;
typedef long long ll;
const int inf = INT_MAX / 2;
const ll infl = 1LL << 60;
const ll mod = 1e9 + 7;
template <typename T> ostream &operator<<(ostream &os, vector<T> v) {
for (auto &i : v)
os << i << " ";
return o... | #include <bits/stdc++.h>
#define rep(i, a, b) for (int i = a; i < b; i++)
using namespace std;
typedef long long ll;
const int inf = INT_MAX / 2;
const ll infl = 1LL << 60;
const ll mod = 1e9 + 7;
template <typename T> ostream &operator<<(ostream &os, vector<T> v) {
for (auto &i : v)
os << i << " ";
return o... | [
"assignment.variable.change",
"identifier.change"
] | 955,239 | 955,240 | u171804186 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const int N = 2e5 + 5;
ll dp[N];
ll a[N];
ll solve(int i) {
if (i <= 1)
return 0;
else if (dp[i] != -1)
return dp[i];
return dp[i] = min(abs(a[i] - a[i - 2]) + solve(i - 2),
abs(a[i] - a[i - 1]) + solve(i - 1));
}... | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const int N = 2e5 + 5;
ll dp[N];
ll a[N];
ll solve(int i) {
if (i <= 1)
return 0;
else if (dp[i] != -1)
return dp[i];
return dp[i] = min(abs(a[i] - a[i - 2]) + solve(i - 2),
abs(a[i] - a[i - 1]) + solve(i - 1));
}... | [
"assignment.variable.change",
"identifier.change"
] | 955,241 | 955,242 | u109008163 | cpp |
p03160 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define ll long long
#define ull unsigned long long
#define l long
#define xx 1000000007
#define max 1000
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.t... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define ll long long
#define ull unsigned long long
#define l long
#define xx 1000000007
#define max 1000
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.t... | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 955,249 | 955,250 | u253526353 | cpp |
p03160 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define ll long long
#define ull unsigned long long
#define l long
#define xx 1000000007
#define max 1000
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.t... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define ll long long
#define ull unsigned long long
#define l long
#define xx 1000000007
#define max 1000
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.t... | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 955,251 | 955,250 | u253526353 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const long long INF = 1LL < 60;
int main... | #include <bits/stdc++.h>
using namespace std;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const long long INF = 1LL << 60;
int mai... | [
"expression.operation.binary.change",
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change"
] | 955,260 | 955,261 | u665871498 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int dp[n];
dp[0] = 0;
dp[1] = arr[1] - arr[0];
for (int i = 2; i < n; i++) {
int a = dp[i - 1] + abs(arr[i] - arr[i - 1]);
int b = dp[i - 2] + abs(arr[i] ... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int dp[n];
dp[0] = 0;
dp[1] = abs(arr[1] - arr[0]);
for (int i = 2; i < n; i++) {
int a = dp[i - 1] + abs(arr[i] - arr[i - 1]);
int b = dp[i - 2] + abs(ar... | [
"call.add",
"call.arguments.change"
] | 955,262 | 955,263 | u801786962 | cpp |
p03160 | #include <bits/stdc++.h>
#define ll long long
#define all(v) v.begin(), v.end()
#define pb push_back
#define f first
#define s second
#define mp make_pair
#define tr(con) for (auto it = con.begin(); it != con.end(); it++)
#define INF 1e9 + 7 // 1 * 10^9+ 7
#define rep(i, l, r) for (ll i = l; i <= r; i++)
#define fo(i, ... | #include <bits/stdc++.h>
#define ll long long
#define all(v) v.begin(), v.end()
#define pb push_back
#define f first
#define s second
#define mp make_pair
#define tr(con) for (auto it = con.begin(); it != con.end(); it++)
#define INF 1e9 + 7 // 1 * 10^9+ 7
#define rep(i, l, r) for (ll i = l; i <= r; i++)
#define fo(i, ... | [
"call.add",
"call.arguments.change"
] | 955,264 | 955,265 | u243556669 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define MAX_N 100000
int dp[MAX_N];
int main() {
int n;
cin >> n;
int step[n];
for (int i = 0; i < n; i++) {
cin >> step[i];
}
dp[0] = 0;
dp[1] = dp[0] + abs(step[1] - step[0]);
for (int i = 2; i < n; i++) {
dp[i] = min(dp[i - 1] + abs(step[i] - st... | #include <bits/stdc++.h>
using namespace std;
#define MAX_N 100000
int long dp[MAX_N];
int main() {
int n;
cin >> n;
int step[n];
for (int i = 0; i < n; i++) {
cin >> step[i];
}
dp[0] = 0;
dp[1] = dp[0] + abs(step[1] - step[0]);
for (int i = 2; i < n; i++) {
dp[i] = min(dp[i - 1] + abs(step[i]... | [
"variable_declaration.array_dimensions.change",
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 955,269 | 955,270 | u158628538 | cpp |
p03160 | #include <climits>
#include <iostream>
using namespace std;
long long int arr[100001];
long long int store[100001];
long long int find(long long int n, long long int k) {
if (store[n] != -1) {
return store[n];
} else {
long long int min1 = INT_MAX, cost = 0, i;
for (i = 1; n - i >= 0 && i <= k; ++i) ... | #include <climits>
#include <iostream>
using namespace std;
long long int arr[100001];
long long int store[100001];
long long int find(long long int n, long long int k) {
if (store[n] != -1) {
return store[n];
} else {
long long int min1 = INT_MAX, cost = 0, i;
for (i = 1; n - i > 0 && i <= k; ++i) {... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"literal.number.change",
"assignment.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 955,273 | 955,272 | u133712390 | 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 *table = new int[N];
table[0] = 0;
table[1] = abs(h[0] - h[1]);
table[2] = min(table[0] + abs(h[1] - h[2]), abs(h[0] - h[2]));
for (int i = 3; i < N; i++... | #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 *table = new int[N];
table[0] = 0;
table[1] = abs(h[0] - h[1]);
table[2] = min(table[1] + abs(h[1] - h[2]), abs(h[0] - h[2]));
for (int i = 3; i < N; i++... | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 955,274 | 955,275 | u995090660 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define pb push_back
#define S second
#define F first
#define f(i, n) for (int i = 0; i < n; i++)
#define fast \
ios_base::sync_with_stdio(0); ... | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define pb push_back
#define S second
#define F first
#define f(i, n) for (int i = 0; i < n; i++)
#define fast \
ios_base::sync_with_stdio(0); ... | [
"expression.operation.binary.add"
] | 955,284 | 955,285 | u680493942 | cpp |
p03160 | #include <iostream>
using namespace std;
const int INF = 1e9;
int abs(int n) {
if (n >= 0)
return n;
else
return -n;
}
int min(int a, int b) {
if (a <= b)
return a;
else
return b;
}
main() {
int N;
cin >> N;
int h[N];
for (int ii = 0; ii < N; ii++) {
cin >> h[ii];
}
int dp[N];... | #include <iostream>
using namespace std;
const int INF = 1e9;
int abs(int n) {
if (n >= 0)
return n;
else
return -n;
}
int min(int a, int b) {
if (a <= b)
return a;
else
return b;
}
main() {
int N;
cin >> N;
int h[N];
for (int ii = 0; ii < N; ii++) {
cin >> h[ii];
}
int dp[N];... | [
"literal.number.change",
"expression.operation.binary.change"
] | 955,286 | 955,287 | u346834985 | cpp |
p03160 | #include <algorithm>
#include <cmath>
#include <cstdio>
using namespace std;
typedef long long ll;
int main() {
int n;
ll h[100000], dp[100010];
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d", &h[i]);
for (int i = 0; i < n; i++)
dp[i] = 200000;
dp[0] = 0;
dp[1] = abs(h[0] - h[1]);
f... | #include <algorithm>
#include <cmath>
#include <cstdio>
using namespace std;
typedef long long ll;
int main() {
int n, h[100000];
ll dp[100010];
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d", &h[i]);
for (int i = 0; i < n; i++)
dp[i] = 2000000000;
dp[0] = 0;
dp[1] = abs(h[0] - h[1]);... | [
"literal.number.change",
"assignment.value.change"
] | 955,288 | 955,289 | u673980701 | cpp |
p03160 | #include <algorithm>
#include <cmath>
#include <cstdio>
using namespace std;
typedef long long ll;
int main() {
int n;
ll h[100000], dp[100010];
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d", &h[i]);
for (int i = 0; i < 100010; i++)
dp[i] = 100000;
dp[0] = 0;
dp[1] = abs(h[0] - h[1])... | #include <algorithm>
#include <cmath>
#include <cstdio>
using namespace std;
typedef long long ll;
int main() {
int n, h[100000];
ll dp[100010];
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d", &h[i]);
for (int i = 0; i < n; i++)
dp[i] = 2000000000;
dp[0] = 0;
dp[1] = abs(h[0] - h[1]);... | [
"identifier.replace.add",
"literal.replace.remove",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"literal.number.change",
"assignment.value.change"
] | 955,290 | 955,289 | u673980701 | cpp |
p03160 | #include <algorithm>
#include <cmath>
#include <cstdio>
using namespace std;
typedef long long ll;
int main() {
int n;
ll h[100010], dp[100010];
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d", &h[i]);
for (int i = 0; i < n; i++)
dp[i] = 100000;
dp[0] = 0;
dp[1] = abs(h[0] - h[1]);
f... | #include <algorithm>
#include <cmath>
#include <cstdio>
using namespace std;
typedef long long ll;
int main() {
int n, h[100000];
ll dp[100010];
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d", &h[i]);
for (int i = 0; i < n; i++)
dp[i] = 2000000000;
dp[0] = 0;
dp[1] = abs(h[0] - h[1]);... | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"assignment.value.change"
] | 955,291 | 955,289 | u673980701 | cpp |
p03160 | #include <algorithm>
#include <cmath>
#include <cstdio>
using namespace std;
typedef long long ll;
int main() {
int n;
ll h[100000], dp[100010];
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d", &h[i]);
for (int i = 0; i < n; i++)
dp[i] = 100000;
dp[0] = 0;
dp[1] = abs(h[0] - h[1]);
f... | #include <algorithm>
#include <cmath>
#include <cstdio>
using namespace std;
typedef long long ll;
int main() {
int n, h[100000];
ll dp[100010];
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d", &h[i]);
for (int i = 0; i < n; i++)
dp[i] = 2000000000;
dp[0] = 0;
dp[1] = abs(h[0] - h[1]);... | [
"literal.number.change",
"assignment.value.change"
] | 955,292 | 955,289 | u673980701 | cpp |
p03160 | #include <algorithm>
#include <cmath>
#include <cstdio>
using namespace std;
typedef long long ll;
int main() {
int n, h[100000];
ll dp[100010];
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d", &h[i]);
for (int i = 0; i < n; i++)
dp[i] = 100000;
dp[0] = 0;
dp[1] = abs(h[0] - h[1]);
f... | #include <algorithm>
#include <cmath>
#include <cstdio>
using namespace std;
typedef long long ll;
int main() {
int n, h[100000];
ll dp[100010];
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d", &h[i]);
for (int i = 0; i < n; i++)
dp[i] = 2000000000;
dp[0] = 0;
dp[1] = abs(h[0] - h[1]);... | [
"literal.number.change",
"assignment.value.change"
] | 955,293 | 955,289 | u673980701 | cpp |
p03160 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define FORD(i, a, b) for (int i = (a); i >= (b); --i)
#define RI(i, n) FOR(i, 1, (n))
#define REP(... | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define FORD(i, a, b) for (int i = (a); i >= (b); --i)
#define RI(i, n) FOR(i, 1, (n))
#define REP(... | [
"identifier.change",
"call.function.change",
"call.arguments.add"
] | 955,294 | 955,295 | u101662185 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int h[n + 1];
h[0] = 0;
for (int i = 1; i <= n; i++)
cin >> h[i];
int dp[n + 1];
dp[0] = 0;
dp[1] = 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 ... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int h[n + 1];
h[0] = 0;
for (int i = 1; i <= n; i++)
cin >> h[i];
int dp[n + 1];
dp[0] = 10001;
dp[1] = 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] - ... | [
"literal.number.change",
"assignment.value.change"
] | 955,298 | 955,299 | u422029489 | cpp |
p03160 | #include <bits/stdc++.h>
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define sz(x) ll(x.size())
using namespace std;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
int main() {
ll n, INF = 10000000000;
cin >> n;
vector<... | #include <bits/stdc++.h>
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define sz(x) ll(x.size())
using namespace std;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
int main() {
ll n, INF = 10000000000;
cin >> n;
vector<... | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 955,307 | 955,308 | u059207724 | cpp |
p03160 | // CODE by Kazhybay Askar
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tu... | // CODE by Kazhybay Askar
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tu... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"control_flow.branch.if.condition.change"
] | 955,311 | 955,312 | u955953023 | cpp |
p03160 | #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int *h = new int[n];
for (int i = 0; i < n; i++)
cin >> h[i];
int *dp = new int[n];
dp[0] = 0;
dp[1] = abs(h[1] - h[0]);
for (int i = 0; i < n; i++) {
int t1, t2;
t1 = h[i - 1] + abs(h[i - 1] - h[i]);
t2 = h[i - 2] +... | #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int *h = new int[n];
for (int i = 0; i < n; i++)
cin >> h[i];
int *dp = new int[n];
dp[0] = 0;
dp[1] = abs(h[1] - h[0]);
for (int i = 2; i < n; i++) {
int t1, t2;
t1 = dp[i - 1] + abs(h[i - 1] - h[i]);
t2 = dp[i - 2]... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 955,313 | 955,314 | u492511953 | cpp |
p03160 | // Program.cpp
// Problem Statement -
#include <algorithm>
#include <bits/stdc++.h>
#include <map>
#include <unordered_map>
using namespace std;
// Author: Varun Goyal (@govarun)
#define f(i, n) for (int i = 0; i < (n); ++i)
#define fa(i, a, n) for (int i = (a); i <= (n); ++i)
#define fd(i, a, n) for (int i = (a); i... | // Program.cpp
// Problem Statement -
#include <algorithm>
#include <bits/stdc++.h>
#include <map>
#include <unordered_map>
using namespace std;
// Author: Varun Goyal (@govarun)
#define f(i, n) for (int i = 0; i < (n); ++i)
#define fa(i, a, n) for (int i = (a); i <= (n); ++i)
#define fd(i, a, n) for (int i = (a); i... | [
"variable_declaration.type.change"
] | 955,328 | 955,329 | u684375950 | cpp |
p03160 | #include <iostream>
#include <vector>
using namespace std;
const int INF = 10e+5;
int main() {
// your code goes here
int n, a;
cin >> n;
vector<int> h(n);
vector<int> dp(n, INF);
for (int i = 0; i < n; i++) {
cin >> a;
h[i] = a;
}
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = i ... | #include <iostream>
#include <vector>
using namespace std;
const int INF = 1e9 + 5;
int main() {
// your code goes here
int n, a;
cin >> n;
vector<int> h(n);
vector<int> dp(n, INF);
for (int i = 0; i < n; i++) {
cin >> a;
h[i] = a;
}
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = ... | [
"literal.number.change"
] | 955,336 | 955,337 | u819054341 | cpp |
p03160 | #include <iostream>
#include <math.h>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n, temp;
cin >> n;
vector<int> cost;
for (int i = 0; i < n; i++) {
cin >> temp;
cost.push_back(temp);
}
vector<int> dp(n, 0);
dp[0] = cost[0];
dp[... | #include <iostream>
#include <math.h>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n, temp;
cin >> n;
vector<int> cost;
for (int i = 0; i < n; i++) {
cin >> temp;
cost.push_back(temp);
}
vector<int> dp(n, 0);
dp[0] = 0;
dp[1] = a... | [] | 955,344 | 955,345 | u764355221 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int cost[n];
for (int i = 0; i < n; i++)
cin >> cost[i];
long dp[n];
dp[0] = 0;
dp[1] = abs(cost[1]);
for (int i = 2; i < n; i++) {
dp[i] = min(dp[i - 2] + abs(cost[i - 2] - cost[i]),
dp[i - 1] + abs(cost... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int cost[n];
for (int i = 0; i < n; i++)
cin >> cost[i];
long dp[n];
dp[0] = 0;
dp[1] = abs(cost[1] - cost[0]);
for (int i = 2; i < n; i++) {
dp[i] = min(dp[i - 2] + abs(cost[i - 2] - cost[i]),
dp[i - 1] ... | [
"assignment.change"
] | 955,346 | 955,347 | u371051907 | cpp |
p03160 | #include <algorithm>
#include <cmath>
#include <iostream>
using namespace std;
long long N;
int main() {
long long i, h[100005], d[100005];
cin >> N;
h[0] = 0;
d[1] = 0;
d[0] = -1000000000;
for (i = 1; i <= N; i++)
cin >> h[i];
for (i = 2; i <= N; i++) {
d[i] =
min(d[i - 1] + abs(h[i] - h... | #include <algorithm>
#include <cmath>
#include <iostream>
using namespace std;
long long N;
int main() {
long long i, h[100005], d[100005];
cin >> N;
h[0] = 0;
d[1] = 0;
d[0] = 1000000000;
for (i = 1; i <= N; i++)
cin >> h[i];
for (i = 2; i <= N; i++) {
d[i] =
min(d[i - 1] + abs(h[i] - h[... | [
"expression.operation.unary.arithmetic.remove"
] | 955,350 | 955,351 | u432635701 | cpp |
p03160 | #include <algorithm>
#include <cmath>
#include <iostream>
using namespace std;
long long N;
int main() {
long long i, h[100005], d[100005];
cin >> N;
h[0] = 0;
d[1] = 0;
d[0] = 0;
for (i = 1; i <= N; i++)
cin >> h[i];
for (i = 2; i <= N; i++) {
d[i] =
min(d[i - 1] + abs(h[i] - h[i - 1]), ... | #include <algorithm>
#include <cmath>
#include <iostream>
using namespace std;
long long N;
int main() {
long long i, h[100005], d[100005];
cin >> N;
h[0] = 0;
d[1] = 0;
d[0] = 1000000000;
for (i = 1; i <= N; i++)
cin >> h[i];
for (i = 2; i <= N; i++) {
d[i] =
min(d[i - 1] + abs(h[i] - h[... | [
"literal.number.change",
"assignment.value.change"
] | 955,352 | 955,351 | u432635701 | cpp |
p03160 | #include <algorithm>
#include <cmath>
#include <iostream>
using namespace std;
int N;
int main() {
int i, h[100005], d[100005];
cin >> N;
h[0] = 0;
d[1] = 0;
d[0] = 0;
for (i = 1; i <= N; i++)
cin >> h[i];
for (i = 2; i <= N; i++) {
d[i] =
min(d[i - 1] + abs(h[i] - h[i - 1]), d[i - 2] + a... | #include <algorithm>
#include <cmath>
#include <iostream>
using namespace std;
long long N;
int main() {
long long i, h[100005], d[100005];
cin >> N;
h[0] = 0;
d[1] = 0;
d[0] = 1000000000;
for (i = 1; i <= N; i++)
cin >> h[i];
for (i = 2; i <= N; i++) {
d[i] =
min(d[i - 1] + abs(h[i] - h[... | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"literal.number.change",
"assignment.value.change"
] | 955,353 | 955,351 | u432635701 | cpp |
p03160 | #include <iostream>
#include <vector>
int main() {
int n;
std::cin >> n;
std::vector<int> h;
for (int i = 0; i < n; i++) {
int value;
std::cin >> value;
h.push_back(value);
}
std::vector<int> dp(n + 1);
dp[1] = abs(h[1] - h[0]);
dp[2] = std::min(abs(h[2] - h[0]), dp[1] + h[2] - h[0]);
... | #include <iostream>
#include <vector>
int main() {
int n;
std::cin >> n;
std::vector<int> h;
for (int i = 0; i < n; i++) {
int value;
std::cin >> value;
h.push_back(value);
}
std::vector<int> dp(n + 1);
dp[1] = abs(h[1] - h[0]);
dp[2] = std::min(abs(h[2] - h[0]), dp[1] + abs(h[2] - h[0]))... | [
"call.add",
"call.arguments.change"
] | 955,354 | 955,355 | u290926443 | cpp |
p03160 | #include <algorithm>
#include <bits/stdc++.h>
#include <cstring>
#include <iostream>
using namespace std;
const int N = 1e3 + 6, M = 1e5 + 5, OO = 0x3f3f3f3f;
int n, arr[N], op1, op2, dp[N];
int frog(int i) {
if (i < 0)
return 0;
if (dp[i] != -1)
return dp[i];
op1 = abs(arr[i] - arr[i - 1]) + frog(i - ... | #include <algorithm>
#include <bits/stdc++.h>
#include <cstring>
#include <iostream>
using namespace std;
const int N = 1e5 + 6, M = 1e5 + 5, OO = 0x3f3f3f3f;
int n, arr[N], op1, op2, dp[N];
int frog(int i) {
if (i <= 0)
return 0;
if (dp[i] != -1)
return dp[i];
op1 = abs(arr[i] - arr[i - 1]) + frog(i -... | [
"literal.number.change",
"expression.operation.binary.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 955,358 | 955,357 | u266150970 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int dp[1100];
for (int i = 0; i < 110000; i++)
dp[i] = 1000000000;
int h[N];
for (int i = 0; i < N; i++)
cin >> h[i];
dp[0] = 0;
dp[1] = abs(h[1] - h[0]);
// cout<<dp[0]<<endl<<dp[1]<<endl;
for (int i = 2; i < N; ... | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int dp[110000];
for (int i = 0; i < 110000; i++)
dp[i] = 1000000000;
int h[N];
for (int i = 0; i < N; i++)
cin >> h[i];
dp[0] = 0;
dp[1] = abs(h[1] - h[0]);
// cout<<dp[0]<<endl<<dp[1]<<endl;
for (int i = 2; i < N... | [
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 955,363 | 955,364 | u652009496 | 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[n];
int cost[n] = {0};
cost[1] = abs(h[0] - h[1]);
cost[2] = min(abs(h[0] - h[2]), cost[1] + abs(h[1] - h[2]));
for (int i = 3; i < n; i++)
cost[i] = min(cost[i - 1] + abs(... | #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 cost[n] = {0};
cost[1] = abs(h[0] - h[1]);
cost[2] = min(abs(h[0] - h[2]), cost[1] + abs(h[1] - h[2]));
for (int i = 3; i < n; i++)
cost[i] = min(cost[i - 1] + abs(... | [
"identifier.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 955,368 | 955,369 | u231447805 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define all(v) (v).begin(), (v).end()
#define lp(i, n) for (int i = 0; i < (n); ++i)
#define lpp(i, n) for (int i = 1; i <= (n); ++i)
#define sz(v) (int)(v).size()
#define int long long
#define mod 100000007
string x;
int32_t main() {
int n, t;
cin >> n;
int arr[n +... | #include <bits/stdc++.h>
using namespace std;
#define all(v) (v).begin(), (v).end()
#define lp(i, n) for (int i = 0; i < (n); ++i)
#define lpp(i, n) for (int i = 1; i <= (n); ++i)
#define sz(v) (int)(v).size()
#define int long long
#define mod 100000007
string x;
int32_t main() {
int n, t;
cin >> n;
int arr[n +... | [
"literal.number.change",
"assignment.value.change"
] | 955,372 | 955,373 | u090634452 | cpp |
p03160 | #include <bits/stdc++.h>
#define IO ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
using namespace std;
typedef long long ll;
typedef struct data {
ll x, y;
bool operator<(const data &a) const { return x < a.x; }
} stu;
ll n, m, k, x;
ll arr[600000];
ll dp[600000];
void solve() {
x = 999999999l;
memse... | #include <bits/stdc++.h>
#define IO ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
using namespace std;
typedef long long ll;
typedef struct data {
ll x, y;
bool operator<(const data &a) const { return x < a.x; }
} stu;
ll n, m, k, x;
ll arr[600000];
ll dp[600000];
void solve() {
x = 10000;
memset(dp,... | [
"literal.number.change",
"assignment.value.change"
] | 955,374 | 955,375 | u090634452 | cpp |
p03160 | #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <queue>
#include <string>
#include <utility>
#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 ... | #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <queue>
#include <string>
#include <utility>
#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 ... | [
"literal.number.change",
"assignment.value.change"
] | 955,378 | 955,379 | u342005896 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
void solve();
int main() {
// freopen("SNOOKER.inp","r",stdin);
// freopen("SNOOKER.out","w",stdout);
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
solve();
}
/*----------------------------------------------------------------------
-------------------------... | #include <bits/stdc++.h>
using namespace std;
void solve();
int main() {
// freopen("SNOOKER.inp","r",stdin);
// freopen("SNOOKER.out","w",stdout);
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
solve();
}
/*----------------------------------------------------------------------
-------------------------... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 955,380 | 955,381 | u307631662 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
long long a[t] = {0}, b[t] = {0};
for (long long i = 0; i < t; i++) {
cin >> a[i];
if (i == 0) {
b[i] = 0;
} else if (i == 1) {
b[i] = (abs(a[1] - a[0]));
} else if (i == 2) {
long long y = (abs(a... | #include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
long long a[t] = {0}, b[t] = {0};
for (long long i = 0; i < t; i++) {
cin >> a[i];
if (i == 0) {
b[i] = 0;
} else if (i == 1) {
b[i] = (abs(a[1] - a[0]));
} else if (i == 2) {
long long y = (abs(a... | [
"call.arguments.change"
] | 955,388 | 955,389 | u389477056 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
#define pb push_back
typedef long long ll;
const int INF = 1000000000;
const long INF64 = 1000000000000000ll;
const ll MOD = 1000000007ll;
int main() {
int n;
std::cin >> n;
st... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
#define pb push_back
typedef long long ll;
const int INF = 1000000000;
const long INF64 = 1000000000000000ll;
const ll MOD = 1000000007ll;
int main() {
int n;
std::cin >> n;
st... | [] | 955,395 | 955,396 | u539011156 | cpp |
p03160 | #include <bits/stdc++.h> /*
#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp> // Including */
using namespace std;
// using namespace __gnu_pbds;
// typedefs
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
... | #include <bits/stdc++.h> /*
#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp> // Including */
using namespace std;
// using namespace __gnu_pbds;
// typedefs
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
... | [
"variable_declaration.type.change",
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 955,399 | 955,400 | u883391587 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 3;
long long h[N], dp[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
for (int i = 1; i <= n; ++i)
cin >> h[i];
for (int i = 2; i <= n; ++i) {
dp[i] = dp[i - 1] + abs(h[i] - h[i - 1]);
dp[... | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 3;
long long h[N], dp[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
for (int i = 1; i <= n; ++i)
cin >> h[i];
for (int i = 2; i <= n; ++i) {
dp[i] = dp[i - 1] + abs(h[i] - h[i - 1]);
if ... | [
"control_flow.branch.if.add"
] | 955,401 | 955,402 | u936529286 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
v.push_back(x);
}
vector<int> dp(v.size(), 1e6);
dp[0] = 0;
for (int i = 1; i < v.size(); i++) {
for (int j = i + 1; j <= i + 2; j++) {
if (j <... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
v.push_back(x);
}
vector<int> dp(v.size(), 1e9);
dp[0] = 0;
for (int i = 0; i < v.size(); i++) {
for (int j = i + 1; j <= i + 2; j++) {
if (j <... | [
"literal.number.change",
"call.arguments.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 955,408 | 955,409 | u447297324 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
v.push_back(x);
}
vector<int> dp(v.size(), 1e6);
dp[0] = 0;
for (int i = 0; i < v.size(); i++) {
for (int j = i + 1; j <= i + 2; j++) {
if (j <... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
v.push_back(x);
}
vector<int> dp(v.size(), 1e9);
dp[0] = 0;
for (int i = 0; i < v.size(); i++) {
for (int j = i + 1; j <= i + 2; j++) {
if (j <... | [
"literal.number.change",
"call.arguments.change"
] | 955,410 | 955,409 | u447297324 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define pi 3.14159265359
#define int long long
#define pii pair<int, int>
#define ld long double
const int mod = 1e9 + 7;
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, -1, 0, 1};
int bin(multiset<int> &s) {
int l = 0, r = s.size() - 1, mid, ans = 1;
while (l <= r) {
m... | #include <bits/stdc++.h>
using namespace std;
#define pi 3.14159265359
#define int long long
#define pii pair<int, int>
#define ld long double
const int mod = 1e9 + 7;
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, -1, 0, 1};
int bin(multiset<int> &s) {
int l = 0, r = s.size() - 1, mid, ans = 1;
while (l <= r) {
m... | [
"call.add",
"call.arguments.change"
] | 955,413 | 955,414 | u094099882 | cpp |
p03160 | #include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (int(i) = (a); (i) < (b); (i)++)
#define REP(i, n) FOR(i, 0, n)
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... | #include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (int(i) = (a); (i) < (b); (i)++)
#define REP(i, n) FOR(i, 0, n)
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... | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 955,421 | 955,422 | u145078207 | cpp |
p03160 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <iostream>
#include <limits>
#include <queue>
#include <stack>
#include <tuple>
#include <vector>
using namespace std;
#define INF 1100000000000
#define MAX 100000
#define MOD 100000
typedef long lo... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <iostream>
#include <limits>
#include <queue>
#include <stack>
#include <tuple>
#include <vector>
using namespace std;
#define INF 1100000000000
#define MAX 100000
#define MOD 100000
typedef long lo... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 955,429 | 955,430 | u591914971 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int wq[100003], st[100003];
int mic(int g) {
if (g <= 0)
return 0;
if (st[g] == 1e9)
return st[g];
st[g] = mic(g - 1) + abs(wq[g] - wq[g - 1]);
if (g > 1)
st[g] = min(st[g], mic(g - 2) + abs(wq[g] - wq[g - 2]));
return st[g];
}
int main() {
int g, t;... | #include <bits/stdc++.h>
using namespace std;
int wq[100003], st[100003];
int mic(int g) {
if (g <= 0)
return 0;
if (st[g] != 1e9)
return st[g];
st[g] = mic(g - 1) + abs(wq[g] - wq[g - 1]);
if (g > 1)
st[g] = min(st[g], mic(g - 2) + abs(wq[g] - wq[g - 2]));
return st[g];
}
int main() {
int g, t;... | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 955,431 | 955,432 | u648333443 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
// FILE *fi=freopen("1.txt","r",stdin);
int n, a[100001], d[100005];
void nhap() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
d[i] = 100001;
}
}
void process() {
d[1] = 0;
for (int i = 1; i <= n; ++i) {
d[i + 1] = min(d[i ... | #include <bits/stdc++.h>
using namespace std;
// FILE *fi=freopen("1.txt","r",stdin);
int n, a[100001], d[200001];
void nhap() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
d[i] = INT_MAX;
}
}
void process() {
d[1] = 0;
for (int i = 1; i <= n; ++i) {
d[i + 1] = min(d[i... | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 955,435 | 955,436 | u033498359 | cpp |
p03160 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
int h[100010];
for (int i = 1; i <= n; i++) {
cin >> h[i];
}
h[0] = h[1];
int dp[100010];
dp[0] = 0;
dp[1] = 0;
for (int i = 2; i <= n; i++) {
dp[i] = min(dp[i - 2... | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
int h[100010];
for (int i = 1; i <= n; i++) {
cin >> h[i];
}
h[0] = h[1];
int dp[100010];
dp[0] = 0;
dp[1] = 0;
for (int i = 2; i <= n; i++) {
dp[i] = min(dp[i - 2... | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 955,437 | 955,438 | u878660242 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int arr[1000005];
int dp[1000005];
int N;
int dpa(int curN) {
// int mal = abs(arr[lInd]-arr[curN]);
if (curN <= 1)
return 0;
if (curN == 2)
return abs(arr[1] - arr[0]);
if (dp[curN] != -1)
return dp[curN];
return dp[curN] = min(dpa(curN - 1) + abs(a... | #include <bits/stdc++.h>
using namespace std;
int arr[1000005];
int dp[1000005];
int N;
int dpa(int curN) {
// int mal = abs(arr[lInd]-arr[curN]);
if (curN <= 1)
return 0;
if (curN == 2)
return abs(arr[2] - arr[1]);
if (dp[curN] != -1)
return dp[curN];
return dp[curN] = min(dpa(curN - 1) + abs(a... | [
"literal.number.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 955,441 | 955,442 | u258931378 | cpp |
p03160 | #include <bits/stdc++.h>
#define ll long long int
using namespace std;
int findans(vector<int> &arr, int n, vector<int> &dp) {
if (n <= 0)
return 0;
if (n == 0)
return arr[n];
if (dp[n + 1] == -1) {
int val = min(abs(arr[n] - arr[n - 1]) + findans(arr, n - 1, dp),
abs(arr[n] - arr[n ... | #include <bits/stdc++.h>
#define ll long long int
using namespace std;
int findans(vector<int> &arr, int n, vector<int> &dp) {
if (n <= 0)
return 0;
if (n == 0)
return arr[n];
if (dp[n + 1] == -1) {
int val = min(abs(arr[n] - arr[n - 1]) + findans(arr, n - 1, dp),
abs(arr[n] - arr[n ... | [] | 955,443 | 955,444 | u700052359 | cpp |
p03160 | #include <cstring>
#include <iostream>
#include <math.h>
using namespace std;
int a[100001], dp[100001], n;
int solve(int i, int sum) {
if (dp[i] != -1) {
return dp[i];
}
if (i == n - 1) {
return sum;
}
if (i == n - 2) {
return abs(a[i] - a[i + 1]);
}
return dp[i] = min(solve(i + 1, abs(a[i] -... | #include <cstring>
#include <iostream>
#include <math.h>
using namespace std;
int a[100001], dp[100001], n;
int solve(int i, int sum) {
if (dp[i] != -1) {
return dp[i];
}
if (i == n - 1) {
return 0;
}
if (i == n - 2) {
return abs(a[i] - a[i + 1]);
}
return dp[i] = min(solve(i + 1, abs(a[i] - a... | [
"identifier.replace.remove",
"literal.replace.add",
"function.return_value.change"
] | 955,457 | 955,458 | u491569207 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, a) for (int i = 0; i < (a); i++)
#define ALL(a) (a).begin(), (a).end()
typedef long long ll;
typedef pair<int, int> P;
const ll INF = 1e9;
const int MOD = 1e9 + 7;
int N;
ll h[100001];
ll dp[100001];
ll rec(int n) {
if (dp[n] != -1) {
return dp[n];
... | #include <bits/stdc++.h>
using namespace std;
#define REP(i, a) for (int i = 0; i < (a); i++)
#define ALL(a) (a).begin(), (a).end()
typedef long long ll;
typedef pair<int, int> P;
const ll INF = 1e12;
const int MOD = 1e9 + 7;
int N;
ll h[100001];
ll dp[100001];
ll rec(int n) {
if (dp[n] != -1) {
return dp[n];
... | [
"literal.number.change",
"variable_declaration.value.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 955,469 | 955,470 | u366398972 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define M 100000
int N, v[M], dp[M];
inline int sol(int ind) {
if (ind >= N)
return 0;
if (dp[ind] != -1)
return dp[ind];
return dp[ind] = min(abs(v[ind] - v[ind + 1]) + sol(ind + 1),
abs(v[ind] - v[ind + 2]) + sol(ind + 2));
}
int ma... | #include <bits/stdc++.h>
using namespace std;
#define M 100000
int N, v[M], dp[M];
inline int sol(int ind) {
if (ind >= N)
return 1e6;
if (dp[ind] != -1)
return dp[ind];
return dp[ind] = min(abs(v[ind] - v[ind + 1]) + sol(ind + 1),
abs(v[ind] - v[ind + 2]) + sol(ind + 2));
}
int ... | [
"literal.number.change",
"function.return_value.change"
] | 955,471 | 955,472 | u751943287 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int min(int a, int b) { return a < b ? a : b; }
int main() {
int n;
cin >> n;
int dp[n], val[n];
for (int i = 0; i < n; i++) {
cin >> val[i];
}
for (int i = 0; i < n; ++i) {
if (i == 0) {
dp[0] = 0;
// printf("%d ",dp[i] );
} else if (i =... | #include <bits/stdc++.h>
using namespace std;
int min(int a, int b) { return a < b ? a : b; }
int main() {
int n;
cin >> n;
int dp[n], val[n];
for (int i = 0; i < n; i++) {
cin >> val[i];
}
for (int i = 0; i < n; ++i) {
if (i == 0) {
dp[0] = 0;
// printf("%d ",dp[i] );
} else if (i =... | [
"call.add",
"call.arguments.change"
] | 955,473 | 955,474 | u094731512 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using db = double;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using db = double;
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;
}
... | [
"variable_declaration.type.change"
] | 955,475 | 955,476 | u298620933 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll n;
cin >> n;
ll a[n];
for (ll i = 0; i < n; i++)
cin >> a[i];
ll b[n];
b[0] = 0;
b[1] = a[1] - a[0];
if (b[1] < 0)
b[1] = -b[1];
for (ll i = 2; i < n; i++) {
ll c, d;
c = a[i] - a[i - 1];
d = a[i] -... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll n;
cin >> n;
ll a[n];
for (ll i = 0; i < n; i++)
cin >> a[i];
ll b[n];
b[0] = 0;
b[1] = a[1] - a[0];
if (b[1] < 0)
b[1] = -b[1];
for (ll i = 2; i < n; i++) {
ll c, d;
c = a[i] - a[i - 1];
d = a[i] -... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 955,483 | 955,484 | u330689597 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll n;
cin >> n;
ll a[n];
for (ll i = 0; i < n; i++)
cin >> a[i];
ll b[n];
b[0] = 0;
b[1] = a[1] - a[0];
if (b[1] < 0)
b[1] = -b[1];
for (ll i = 2; i < n; i++) {
ll c, d;
c = a[i] - a[i - 1];
d = a[i] -... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll n;
cin >> n;
ll a[n];
for (ll i = 0; i < n; i++)
cin >> a[i];
ll b[n];
b[0] = 0;
b[1] = a[1] - a[0];
if (b[1] < 0)
b[1] = -b[1];
for (ll i = 2; i < n; i++) {
ll c, d;
c = a[i] - a[i - 1];
d = a[i] -... | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 955,485 | 955,484 | u330689597 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("03")
#pragma GCC optimize("unroll-loops")
#define ll long long
#define ms(a) memset(a, 0, sizeof(a))
#define endl '\n'
#define pb push_back
#define mp(a, b) make_pair(a, b)
#define mpp(a, b, c) make_pair(a, make_pair(b, c))
#define fi first
... | #include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("03")
#pragma GCC optimize("unroll-loops")
#define ll long long
#define ms(a) memset(a, 0, sizeof(a))
#define endl '\n'
#define pb push_back
#define mp(a, b) make_pair(a, b)
#define mpp(a, b, c) make_pair(a, make_pair(b, c))
#define fi first
... | [
"control_flow.branch.if.condition.change"
] | 955,494 | 955,495 | u481284462 | cpp |
p03160 | // in the name of god
// if you read this code please search about imam hussain
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define pb push_back
#define endl "\n";
#define migmig \
ios::sync_with_stdio(false); ... | // in the name of god
// if you read this code please search about imam hussain
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define pb push_back
#define endl "\n";
#define migmig \
ios::sync_with_stdio(false); ... | [
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add"
] | 955,505 | 955,506 | u433132072 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int dp[N];
int h[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d", &h[i]), dp[i] = 1 << 30;
dp[1] = 0;
for (int i = 2; i <= n; i++) {
if (i - 1 >= 0)
dp[i] = min(dp[i], dp[i - 1] + abs(h[i] - h[i... | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int dp[N];
int h[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d", &h[i]), dp[i] = 1 << 30;
dp[1] = 0;
for (int i = 2; i <= n; i++) {
if (i - 1 > 0)
dp[i] = min(dp[i], dp[i - 1] + abs(h[i] - h[i ... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 955,507 | 955,508 | u377964143 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int dp[N];
int h[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d", &h[i]), dp[i] = 1e9;
dp[1] = 0;
for (int i = 2; i <= n; i++) {
if (i - 1 >= 0)
dp[i] = min(dp[i], dp[i - 1] + abs(h[i] - h[i - 1... | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int dp[N];
int h[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d", &h[i]), dp[i] = 1 << 30;
dp[1] = 0;
for (int i = 2; i <= n; i++) {
if (i - 1 > 0)
dp[i] = min(dp[i], dp[i - 1] + abs(h[i] - h[i ... | [
"literal.number.change",
"assignment.value.change",
"assignment.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 955,509 | 955,508 | u377964143 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int h[100005];
int n;
int dp[100005];
int solve(int i) {
if (i >= n - 1)
return 0;
if (dp[i] != -1) {
return dp[i];
}
int a = 1e9 + 7, b = 1e9 + 7;
a = solve(i + 1) + abs(h[i] - h[i + 1]);
if (i < n + 2) {
b = solve(i + 2) + abs(h[i] - h[i +... | #include <bits/stdc++.h>
using namespace std;
int h[100005];
int n;
int dp[100005];
int solve(int i) {
if (i >= n - 1)
return 0;
if (dp[i] != -1) {
return dp[i];
}
int a = 1e9 + 7;
int b = 1e9 + 7;
a = solve(i + 1) + abs(h[i] - h[i + 1]);
if (i < n - 2) {
b = solve(i + 2) + abs(h[i] -... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change"
] | 955,510 | 955,511 | u667337429 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
const int INF = 1e9;
int n;
cin >> n;
vector<int> h(n);
REP(i, n) cin >> h[i];
vector<int> dp(n, INF);
dp[0] = 0;
for (int i = 1; i < n; i++) {
int cost1 = abs(h[i] - h[i - 1]);
dp[i]... | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
const int INF = 1e9;
int n;
cin >> n;
vector<int> h(n);
REP(i, n) cin >> h[i];
vector<int> dp(n, INF);
dp[0] = 0;
for (int i = 1; i < n; i++) {
int cost1 = abs(h[i] - h[i - 1]);
dp[i]... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 955,512 | 955,513 | u590000849 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int gcd(long long a, long long b) {
long long M = max(a, b), m = min(a, b);
while (m != 0) {
long long r = M % m;
M = m;
m = r;
}
return M;
}
int digit_sum(long long n) {
long long ans;
while (n != 0) {
ans += n % 10;
n /= 10;
}
return ... | #include <bits/stdc++.h>
using namespace std;
int gcd(long long a, long long b) {
long long M = max(a, b), m = min(a, b);
while (m != 0) {
long long r = M % m;
M = m;
m = r;
}
return M;
}
int digit_sum(long long n) {
long long ans;
while (n != 0) {
ans += n % 10;
n /= 10;
}
return ... | [
"literal.number.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 955,516 | 955,517 | u522993719 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
void print(vector<int> v) {
for (const auto &i : v)
cout << i << " ";
cout << "\n";
}
const int INF = 1e9 + 5;
int main(int argc, char **argv) {
int n;
cin >> n;
vector<int> s(n);
vector<int> dp(n, 999);
dp[0] = 0;
for (int i = 0; i < n; ++i) {
cin ... | #include <bits/stdc++.h>
using namespace std;
void print(vector<int> v) {
for (const auto &i : v)
cout << i << " ";
cout << "\n";
}
const int INF = 1e9 + 5;
int main(int argc, char **argv) {
int n;
cin >> n;
vector<int> s(n);
vector<int> dp(n, INF);
dp[0] = 0;
for (int i = 0; i < n; ++i) {
cin ... | [
"call.arguments.change"
] | 955,522 | 955,523 | u709540959 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
void print(vector<int> v) {
for (const auto &i : v)
cout << i << " ";
cout << "\n";
}
const int INF = 1e9 + 5;
int main(int argc, char **argv) {
int n;
cin >> n;
vector<int> s(n);
vector<int> dp(n, 999);
dp[0] = 0;
for (int i = 0; i < n; ++i) {
cin ... | #include <bits/stdc++.h>
using namespace std;
void print(vector<int> v) {
for (const auto &i : v)
cout << i << " ";
cout << "\n";
}
const int INF = 1e9 + 5;
int main(int argc, char **argv) {
int n;
cin >> n;
vector<int> s(n);
vector<int> dp(n, INF);
dp[0] = 0;
for (int i = 0; i < n; ++i) {
cin ... | [
"call.arguments.change",
"literal.string.change",
"io.output.change",
"io.output.newline.add"
] | 955,524 | 955,523 | u709540959 | cpp |
p03160 | #include <bits/stdc++.h>
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;
long long dp[100010];
... | #include <bits/stdc++.h>
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;
long long dp[100010];
... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 955,532 | 955,533 | u144029820 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std; // cont number of ones from 0 to n in binarry
// representation
#define ll long long
int main() {
int n;
cin >> n;
int ar[n];
for (int i = 0; i < n; i++)
cin >> ar[i];
ll dp[n];
dp[0] = 0, dp[1] = abs(ar[0] - ar[1]);
for (int i = 2; ... | #include <bits/stdc++.h>
using namespace std; // cont number of ones from 0 to n in binarry
// representation
#define ll long long
int main() {
int n;
cin >> n;
int ar[n];
for (int i = 0; i < n; i++)
cin >> ar[i];
ll dp[n];
dp[0] = 0, dp[1] = abs(ar[0] - ar[1]);
for (int i = 2; ... | [
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 955,534 | 955,535 | u959485410 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std; // cont number of ones from 0 to n in binarry
// representation
#define ll long long
int main() {
int n;
cin >> n;
int ar[n];
for (int i = 0; i < n; i++)
cin >> ar[i];
ll dp[n];
dp[0] = 0, dp[1] = abs(ar[0] - ar[1]);
for (int i = 2; ... | #include <bits/stdc++.h>
using namespace std; // cont number of ones from 0 to n in binarry
// representation
#define ll long long
int main() {
int n;
cin >> n;
int ar[n];
for (int i = 0; i < n; i++)
cin >> ar[i];
ll dp[n];
dp[0] = 0, dp[1] = abs(ar[0] - ar[1]);
for (int i = 2; ... | [
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 955,536 | 955,535 | u959485410 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std; // cont number of ones from 0 to n in binarry
// representation
#define ll long long
int main() {
int n;
cin >> n;
int ar[n];
for (int i = 0; i < n; i++)
cin >> ar[i];
int dp[n];
dp[0] = 0, dp[1] = abs(ar[0] - ar[1]);
for (int i = 2;... | #include <bits/stdc++.h>
using namespace std; // cont number of ones from 0 to n in binarry
// representation
#define ll long long
int main() {
int n;
cin >> n;
int ar[n];
for (int i = 0; i < n; i++)
cin >> ar[i];
ll dp[n];
dp[0] = 0, dp[1] = abs(ar[0] - ar[1]);
for (int i = 2; ... | [
"variable_declaration.type.change",
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 955,537 | 955,535 | u959485410 | cpp |
p03160 | #include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
#define all(x) (x).begin(), (x).end()
typedef long long ll;
#define rep(i, n) for (ll i = 0, i##_len = (n); i < i##_len; ++i)
#define REP(i, num, n) for (ll i = num, i##_len = (n); i < i##_len; ++i)
template <class T> bool chmax(T &a, const T &... | #include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
#define all(x) (x).begin(), (x).end()
typedef long long ll;
#define rep(i, n) for (ll i = 0, i##_len = (n); i < i##_len; ++i)
#define REP(i, num, n) for (ll i = num, i##_len = (n); i < i##_len; ++i)
template <class T> bool chmax(T &a, const T &... | [
"expression.operation.binary.add"
] | 955,538 | 955,539 | u135572611 | cpp |
p03160 | #include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
#define all(x) (x).begin(), (x).end()
typedef long long ll;
#define rep(i, n) for (ll i = 0, i##_len = (n); i < i##_len; ++i)
#define REP(i, num, n) for (ll i = num, i##_len = (n); i < i##_len; ++i)
template <class T> bool chmax(T &a, const T &... | #include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
#define all(x) (x).begin(), (x).end()
typedef long long ll;
#define rep(i, n) for (ll i = 0, i##_len = (n); i < i##_len; ++i)
#define REP(i, num, n) for (ll i = num, i##_len = (n); i < i##_len; ++i)
template <class T> bool chmax(T &a, const T &... | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 955,540 | 955,541 | u135572611 | cpp |
p03160 | #include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
#define all(x) (x).begin(), (x).end()
typedef long long ll;
#define rep(i, n) for (ll i = 0, i##_len = (n); i < i##_len; ++i)
#define REP(i, num, n) for (ll i = num, i##_len = (n); i < i##_len; ++i)
template <class T> bool chmax(T &a, const T &... | #include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
#define all(x) (x).begin(), (x).end()
typedef long long ll;
#define rep(i, n) for (ll i = 0, i##_len = (n); i < i##_len; ++i)
#define REP(i, num, n) for (ll i = num, i##_len = (n); i < i##_len; ++i)
template <class T> bool chmax(T &a, const T &... | [
"expression.operation.binary.remove"
] | 955,540 | 955,542 | u135572611 | cpp |
p03160 | #include <bits/stdc++.h>
#define all(x) (x).begin(), (x).end()
typedef long long ll;
#define rep(i, n) for (ll i = 0, i##_len = (n); i < i##_len; ++i)
#define REP(i, num, n) for (ll i = num, i##_len = (n); i < i##_len; ++i)
#define repprev(i, a, b) for (ll i = b - 1; i >= a; i--)
#define reprev(i, n) repprev(i, 0, n)
u... | #include <bits/stdc++.h>
#define all(x) (x).begin(), (x).end()
typedef long long ll;
#define rep(i, n) for (ll i = 0, i##_len = (n); i < i##_len; ++i)
#define REP(i, num, n) for (ll i = num, i##_len = (n); i < i##_len; ++i)
#define repprev(i, a, b) for (ll i = b - 1; i >= a; i--)
#define reprev(i, n) repprev(i, 0, n)
u... | [
"expression.operation.binary.add"
] | 955,545 | 955,546 | u135572611 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define mod 1000000007
#define rep(i, a, b) for (ll i = a; i < b; i++)
#define repc(i, a, b, c) \
for (ll i = a; (c > 0 ? i < b : i > b) and c != 0; i += c)
#define mp make_pair
#define pb push_... |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define mod 1000000007
#define rep(i, a, b) for (ll i = a; i < b; i++)
#define repc(i, a, b, c) \
for (ll i = a; (c > 0 ? i < b : i > b) and c != 0; i += c)
#define mp make_pair
#define pb push... | [
"expression.operation.binary.remove",
"assignment.add"
] | 955,551 | 955,552 | u202796595 | cpp |
p03160 | #include <iostream>
#include <vector>
using namespace std;
const int INF = 1e9;
vector<int> arr;
vector<int> dp;
int N;
int solve(int x) {
if (x >= N - 1)
return 0;
if (dp[x] != -1)
return dp[x];
int j1 = abs(arr[x] - arr[x + 1]) + solve(x + 1);
int j2 = INF;
if (x < N - 1)
j2 = abs(arr[x] - a... | #include <iostream>
#include <vector>
using namespace std;
const int INF = 1e9;
vector<int> arr;
vector<int> dp;
int N;
int solve(int x) {
if (x >= N - 1)
return 0;
if (dp[x] != -1)
return dp[x];
int j1 = abs(arr[x] - arr[x + 1]) + solve(x + 1);
int j2 = INF;
if (x < N - 2)
j2 = abs(arr[x] - a... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 955,559 | 955,560 | u610908776 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int h[n], dp[n + 2]{0};
for (int i = 1; i <= n; i++)
cin >> h[i];
dp[2] = 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[... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int h[n], dp[n + 2]{0};
for (int i = 1; i <= n; i++)
cin >> h[i];
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 <... | [
"call.add",
"call.arguments.change"
] | 955,561 | 955,562 | u253715819 | cpp |
p03160 | #include <algorithm>
#include <iostream>
#define AC ios_base::sync_with_stdio(0), cin.tie(0);
using namespace std;
int main(int argc, char **argv) {
// AC
int limit;
cin >> limit;
int *arr = new int[limit];
int *dp = new int[limit];
for (int i = 0; i < limit; i++)
cin >> arr[i];
dp[0] = arr[0], dp[1] ... | #include <algorithm>
#include <iostream>
#define AC ios_base::sync_with_stdio(0), cin.tie(0);
using namespace std;
int main(int argc, char **argv) {
// AC
int limit;
cin >> limit;
int *arr = new int[limit];
int *dp = new int[limit];
for (int i = 0; i < limit; i++)
cin >> arr[i];
dp[0] = 0, dp[1] = abs... | [] | 955,569 | 955,570 | u782898395 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int A(int a) {
if (a < 0)
return -a;
return a;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int arr[200000], N;
int DP[200000];
cin >> N;
for (int i = 0; i < N; i++) {
cin >> arr[i];
}
DP[0] = 0;
DP[1] = arr[1] - arr[0];
for (... | #include <bits/stdc++.h>
using namespace std;
int A(int a) {
if (a < 0)
return -a;
return a;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int arr[200000], N;
int DP[200000];
cin >> N;
for (int i = 0; i < N; i++) {
cin >> arr[i];
}
DP[0] = 0;
DP[1] = A(arr[1] - arr[0]);
fo... | [
"call.add",
"call.arguments.change"
] | 955,579 | 955,580 | u933159466 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int arr[1000000];
int dp[1000000];
for (int i = 0; i < N; i++) {
cin >> arr[i];
}
dp[0] = 0;
dp[1] = abs(arr[2] - arr[1]);
for (int i = 2; i < N; i++) {
dp[i] = min(abs(arr[i] - arr[i - 1]) + dp[i - 1],
... | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int arr[1000000];
int dp[1000000];
for (int i = 0; i < N; i++) {
cin >> arr[i];
}
dp[0] = 0;
dp[1] = abs(arr[0] - arr[1]);
for (int i = 2; i < N; i++) {
dp[i] = min(abs(arr[i] - arr[i - 1]) + dp[i - 1],
... | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 955,581 | 955,582 | u537207678 | 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] = abs(arr[2] - arr[1]);
for (int i = 2; i < N; i++) {
dp[i] = min(abs(arr[i] - arr[i - 1]) + dp[i - 1],
abs(arr[i] ... | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int arr[1000000];
int dp[1000000];
for (int i = 0; i < N; i++) {
cin >> arr[i];
}
dp[0] = 0;
dp[1] = abs(arr[0] - arr[1]);
for (int i = 2; i < N; i++) {
dp[i] = min(abs(arr[i] - arr[i - 1]) + dp[i - 1],
... | [
"identifier.replace.remove",
"literal.replace.add",
"variable_declaration.array_dimensions.change",
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 955,583 | 955,582 | u537207678 | cpp |
p03160 | #include <bits/stdc++.h>
#define rep(i, cc, n) for (int i = cc; i <= n; ++i)
#define drep(i, cc, n) for (int i = cc; i >= n; --i)
#define sz(s) (int)(s.size())
#define vecprint(v) \
rep(i, 0, v.size() - 1) cout << v[i] << " "; ... | #include <bits/stdc++.h>
#define rep(i, cc, n) for (int i = cc; i <= n; ++i)
#define drep(i, cc, n) for (int i = cc; i >= n; --i)
#define sz(s) (int)(s.size())
#define vecprint(v) \
rep(i, 0, v.size() - 1) cout << v[i] << " "; ... | [
"literal.number.change",
"call.arguments.change",
"assignment.value.change"
] | 955,584 | 955,585 | u736278528 | cpp |
p03160 | #include <bits/stdc++.h>
#define rep(i, cc, n) for (int i = cc; i <= n; ++i)
#define drep(i, cc, n) for (int i = cc; i >= n; --i)
#define sz(s) (int)(s.size())
#define vecprint(v) \
rep(i, 0, v.size() - 1) cout << v[i] << " "; ... | #include <bits/stdc++.h>
#define rep(i, cc, n) for (int i = cc; i <= n; ++i)
#define drep(i, cc, n) for (int i = cc; i >= n; --i)
#define sz(s) (int)(s.size())
#define vecprint(v) \
rep(i, 0, v.size() - 1) cout << v[i] << " "; ... | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"literal.number.change",
"call.arguments.change",
"assignment.value.change"
] | 955,586 | 955,585 | u736278528 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int(i) = 0; (i) < (int)(n); ++(i))
#define REPN(i, m, n) for (int(i) = m; (i) < (int)(n); ++(i))
#define REP_REV(i, n) for (int(i) = (int)(n)-1; (i) >= 0; --(i))
#define REPN_REV(i, m, n) for (int(i) = (int)(n)-1; (i) >= m; --(i))
#define INF 2e9
#d... | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int(i) = 0; (i) < (int)(n); ++(i))
#define REPN(i, m, n) for (int(i) = m; (i) < (int)(n); ++(i))
#define REP_REV(i, n) for (int(i) = (int)(n)-1; (i) >= 0; --(i))
#define REPN_REV(i, m, n) for (int(i) = (int)(n)-1; (i) >= m; --(i))
#define INF 2e9
#d... | [
"call.arguments.change"
] | 955,593 | 955,594 | u127768253 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define x first
#define y second
#define ll long long
#define pi pair<int, int>
#define pl pair<ll, ll>
#define pd pair<double, double>
#define ld long double
#define pld pair<ld, ld>
#define lg length()
#define sz size()
#define vi vector<int>
#define vl vector<ll>
#define... |
#include <bits/stdc++.h>
using namespace std;
#define x first
#define y second
#define ll long long
#define pi pair<int, int>
#define pl pair<ll, ll>
#define pd pair<double, double>
#define ld long double
#define pld pair<ld, ld>
#define lg length()
#define sz size()
#define vi vector<int>
#define vl vector<ll>
#defin... | [] | 955,597 | 955,598 | u663257960 | cpp |
p03160 | #include <iostream>
#include <vector>
using namespace std;
int dp[100050] = {};
int num(int a) {
if (a < 0)
return -a;
else
return a;
}
int min1(int a, int b) {
if (a < b)
return a;
else
return b;
}
int main() {
int n;
cin >> n;
vector<int> h(n + 5);
for (int i = 1; i <= n; i++) {
c... | #include <iostream>
#include <vector>
using namespace std;
int dp[100050] = {};
int num(int a) {
if (a < 0)
return -a;
else
return a;
}
int min1(int a, int b) {
if (a < b)
return a;
else
return b;
}
int main() {
int n;
cin >> n;
vector<int> h(n + 5);
for (int i = 1; i <= n; i++) {
c... | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 955,599 | 955,600 | u313043608 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ar[n];
for (int i = 0; i < n; ++i) {
cin >> ar[i];
}
int dp[n];
dp[0] = 0;
dp[1] = ar[1] - ar[0];
for (int i = 2; i < n; ++i) {
dp[i] = min((dp[i - 1] + abs(ar[i] - ar[i - 1])),
dp[i - 2] + abs(ar[i... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ar[n];
for (int i = 0; i < n; ++i) {
cin >> ar[i];
}
int dp[n];
dp[0] = 0;
dp[1] = abs(ar[1] - ar[0]);
for (int i = 2; i < n; ++i) {
dp[i] = min((dp[i - 1] + abs(ar[i] - ar[i - 1])),
dp[i - 2] + abs... | [
"call.add",
"call.arguments.change"
] | 955,601 | 955,602 | u518232099 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e5 + 10;
ll h[N], dp[N];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++)
cin >> h[i];
for (int i = n - 2; i >= 0; i--) {
dp[i] = dp[i + 1] + abs(h[... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e5 + 10;
ll h[N], dp[N];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++)
cin >> h[i];
for (int i = n - 2; i >= 0; i--) {
dp[i] = dp[i + 1] + abs(h[... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 955,611 | 955,612 | u168698471 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
typedef pair<ll, ll> P;
#define M 1000000007
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<int> dp(n);
dp[0] = 0, dp[1] = abs(a[1] - a[0]);
for (int i = 2; i < n; i++) {
dp[i]... | #include <bits/stdc++.h>
using namespace std;
#define ll long long
typedef pair<ll, ll> P;
#define M 1000000007
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<int> dp(n);
dp[0] = 0, dp[1] = abs(a[1] - a[0]);
for (int i = 2; i < n; i++) {
dp[i]... | [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 955,613 | 955,614 | u987476436 | cpp |
p03160 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <string>
#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... | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <string>
#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... | [
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 955,682 | 955,684 | u855985627 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define forn(i, n) for (int i = 0; i < n; i++)
#define forn1(i, n) for (int i = 1; i <= n; i++)
#define loop(i, sta, end, inc) for (int i = sta; i <= end; i += inc)
#define itr(it, l) for (auto it = l.begin(); it != l.end(); it++)
#define in(a, b, c) assert(b <= a && a <= c... | #include <bits/stdc++.h>
using namespace std;
#define forn(i, n) for (int i = 0; i < n; i++)
#define forn1(i, n) for (int i = 1; i <= n; i++)
#define loop(i, sta, end, inc) for (int i = sta; i <= end; i += inc)
#define itr(it, l) for (auto it = l.begin(); it != l.end(); it++)
#define in(a, b, c) assert(b <= a && a <= c... | [
"literal.number.change",
"variable_access.subscript.index.change",
"io.output.change"
] | 955,704 | 955,708 | u858856811 | cpp |
p03160 | #include <cmath>
#include <iostream>
#include <vector>
using namespace std;
#define INF int(1e9)
int dp[100000000];
int main() {
int N;
cin >> N;
vector<int> v(N + 1);
for (int i = 1; i <= N; i++)
cin >> v[i];
dp[0] = 0;
dp[1] = 0;
dp[2] = v[1] - v[0];
for (int i = 3; i <= N; i++) {
dp[i]... | #include <cmath>
#include <iostream>
#include <vector>
using namespace std;
#define INF int(1e9)
int dp[100000000];
int main() {
int N;
cin >> N;
vector<int> v(N + 1);
for (int i = 1; i <= N; i++)
cin >> v[i];
dp[0] = 0;
dp[1] = 0;
dp[2] = abs(v[2] - v[1]);
for (int i = 3; i <= N; i++) {
... | [
"call.add",
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 955,721 | 955,723 | u492352831 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.