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 ll long long
vector<ll> dp(100002, -1);
ll n;
ll solve(vector<ll> &v, ll i) {
if (i == n - 1)
return 0;
if (dp[i] != -1)
return dp[i];
ll ans = abs(v[i] - v[i + 1]) + solve(v, i + 1);
if (i + 2 < n) {
ans = min(ans, abs(v[i] - v[i + 2]) + solve(v, i + 2));
}
dp[i] = ans;
}
int main() {
cin >> n;
vector<ll> v(n);
for (ll i = 0; i < n; i++) {
cin >> v[i];
}
cout << solve(v, 0);
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
vector<ll> dp(100002, -1);
ll n;
ll solve(vector<ll> &v, ll i) {
if (i == n - 1)
return 0;
if (dp[i] != -1)
return dp[i];
ll ans = abs(v[i] - v[i + 1]) + solve(v, i + 1);
if (i + 2 < n) {
ans = min(ans, abs(v[i] - v[i + 2]) + solve(v, i + 2));
}
return dp[i] = ans;
}
int main() {
cin >> n;
vector<ll> v(n);
for (ll i = 0; i < n; i++) {
cin >> v[i];
}
cout << solve(v, 0);
}
| [
"control_flow.return.add"
] | 952,139 | 952,140 | u075940004 | cpp |
p03160 | #include <bits/stdc++.h>
#define int long long
#define abs llabs
#define INF 10000000LL
using namespace std;
signed main() {
int n, h[100000], dp[10000];
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> h[i];
dp[i] = INF;
}
dp[0] = 0;
for (int i = 0; i < n - 2; ++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 + 1] + abs(h[i] - h[i + 2]));
}
dp[n - 1] = min(dp[n - 1], dp[n - 2] + abs(h[n - 2] - h[n - 1]));
cout << dp[n - 2] << "\n";
}
| #include <bits/stdc++.h>
#define int long long
#define abs llabs
#define INF 10000000000000000LL
using namespace std;
signed main() {
int n, h[100000], dp[100000];
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> h[i];
dp[i] = INF;
}
dp[0] = 0;
for (int i = 0; i < n - 2; ++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]));
}
dp[n - 1] = min(dp[n - 1], dp[n - 2] + abs(h[n - 2] - h[n - 1]));
cout << dp[n - 1] << "\n";
} | [
"preprocessor.define.value.change",
"literal.integer.change",
"literal.number.change",
"variable_declaration.array_dimensions.change",
"expression.operation.binary.remove",
"variable_access.subscript.index.change",
"io.output.change"
] | 952,146 | 952,145 | u652908807 | cpp |
p03160 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <math.h>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
// ===============================================================
// using系
using namespace std;
using ll = long long;
using vl = vector<long long>;
using vll = vector<vector<long long>>;
using vs = vector<string>;
using vc = vector<char>;
using vcc = vector<vector<char>>;
using vm = vector<short>;
using vmm = vector<vector<short>>;
using pii = pair<int, int>;
using psi = pair<string, int>;
using ld = long double;
using ull = unsigned long long;
using ld = long double;
using qul = queue<ll>;
using pql = priority_queue<ll>;
// ========================================================================
// define系
//#define int long long;
#define rep(i, n) for (int i = 0; i < n; i++)
#define REP(i, n) for (int i = 1; i <= n; i++)
// ========================================================================
ll gcd(ll a, ll b) {
if (a % b == 0) {
return (b);
} else {
return (gcd(b, a % b));
}
}
//最大公約数
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
//最小公倍数
ll box(double a) {
ll b = a;
return b;
}
//切り捨て
ll fff(double a) {
ll b = a + 0.5;
return b;
}
//四捨五入
ll mch(ll n) {
if (n == 1)
return 1;
else
return n * mch(n - 1);
}
// 1から整数nまでの階乗を出す(INFで割っていない)
bool prime(ll a) //素数判定、primeならtrue,違うならfalse
{
if (a < 2)
return false;
else if (a == 2)
return true;
else if (a % 2 == 0)
return false;
double m = sqrt(a);
for (int i = 3; i <= m; i += 2) {
if (a % i == 0) {
return false;
}
}
// 素数である
return true;
}
//素数判定
ll modpow(ll a, ll n, ll mod) {
ll hi = 1;
while (n > 0) {
if (n & 1)
hi = hi * a % mod;
a = a * a % mod;
n >>= 1;
}
return hi;
}
//いろいろやります（ただの前座）
ll mg(ll a, ll mod) { return modpow(a, mod - 2, mod); }
//割り算の10^9+7等対策で逆元を出します
// ========================================================================
/*signed*/ int main() {
ll n;
cin >> n;
vl a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
vl 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 - 1]));
}
cout << dp[n - 1] << endl;
return 0;
} | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <math.h>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
// ===============================================================
// using系
using namespace std;
using ll = long long;
using vl = vector<long long>;
using vll = vector<vector<long long>>;
using vs = vector<string>;
using vc = vector<char>;
using vcc = vector<vector<char>>;
using vm = vector<short>;
using vmm = vector<vector<short>>;
using pii = pair<int, int>;
using psi = pair<string, int>;
using ld = long double;
using ull = unsigned long long;
using ld = long double;
using qul = queue<ll>;
using pql = priority_queue<ll>;
// ========================================================================
// define系
//#define int long long;
#define rep(i, n) for (int i = 0; i < n; i++)
#define REP(i, n) for (int i = 1; i <= n; i++)
// ========================================================================
ll gcd(ll a, ll b) {
if (a % b == 0) {
return (b);
} else {
return (gcd(b, a % b));
}
}
//最大公約数
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
//最小公倍数
ll box(double a) {
ll b = a;
return b;
}
//切り捨て
ll fff(double a) {
ll b = a + 0.5;
return b;
}
//四捨五入
ll mch(ll n) {
if (n == 1)
return 1;
else
return n * mch(n - 1);
}
// 1から整数nまでの階乗を出す(INFで割っていない)
bool prime(ll a) //素数判定、primeならtrue,違うならfalse
{
if (a < 2)
return false;
else if (a == 2)
return true;
else if (a % 2 == 0)
return false;
double m = sqrt(a);
for (int i = 3; i <= m; i += 2) {
if (a % i == 0) {
return false;
}
}
// 素数である
return true;
}
//素数判定
ll modpow(ll a, ll n, ll mod) {
ll hi = 1;
while (n > 0) {
if (n & 1)
hi = hi * a % mod;
a = a * a % mod;
n >>= 1;
}
return hi;
}
//いろいろやります（ただの前座）
ll mg(ll a, ll mod) { return modpow(a, mod - 2, mod); }
//割り算の10^9+7等対策で逆元を出します
// ========================================================================
/*signed*/ int main() {
ll n;
cin >> n;
vl a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
vl 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] << endl;
return 0;
} | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 952,147 | 952,148 | u926006934 | cpp |
p03160 | #include <cmath>
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int h[n];
for (int i = 0; i < n; i++)
cin >> h[i];
int dp[n];
dp[0] = 0;
dp[1] = abs(h[1] - h[0]);
for (int i = 2; i < n; i++) {
int o1 = dp[i - 1] + abs(h[i] - h[i - 1]);
int o2 = dp[i - 2] + abs(h[i] - h[i - 1]);
dp[i] = min(o1, o2);
}
cout << dp[n - 1] << endl;
return 0;
} | #include <cmath>
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int h[n];
for (int i = 0; i < n; i++)
cin >> h[i];
int dp[n];
dp[0] = 0;
dp[1] = abs(h[1] - h[0]);
for (int i = 2; i < n; i++) {
int o1 = dp[i - 1] + abs(h[i] - h[i - 1]);
int o2 = dp[i - 2] + abs(h[i] - h[i - 2]);
dp[i] = min(o1, o2);
}
cout << dp[n - 1] << endl;
return 0;
}
| [
"literal.number.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 952,149 | 952,150 | u052603064 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define vll vector<int>
vll dp(1e5 + 1, 0);
int main() {
int i, j, k, n, m, t;
vll h;
cin >> n;
for (i = 0; i < n; i++) {
cin >> j;
h.push_back(j);
}
dp[2] = fabs(h[1] - h[0]);
dp[3] = fabs(h[2] - h[0]);
for (i = 4; i <= n; i++) {
dp[i] = min(fabs(h[i] - h[i - 1]) + dp[i - 1],
fabs(h[i] - h[i - 2]) + dp[i - 2]);
}
cout << dp[n] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define vll vector<int>
vll dp(1e5 + 5, 0);
int main() {
int i, j, k, n, m, t;
vll h;
cin >> n;
for (i = 0; i < n; i++) {
cin >> j;
h.push_back(j);
}
dp[1] = fabs(h[1] - h[0]);
dp[2] = fabs(h[2] - h[0]);
for (i = 3; i <= n; i++) {
dp[i] = min(fabs(h[i] - h[i - 1]) + dp[i - 1],
fabs(h[i] - h[i - 2]) + dp[i - 2]);
}
cout << dp[n - 1] << endl;
return 0;
} | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change",
"assignment.variable.change",
"variable_access.subscript.index.change",
"assignment.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 952,151 | 952,152 | u454814816 | cpp |
p03160 | //#include <bits/stdc++.h>
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string.h>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define ff first
#define ss second
#define ll long long
#define mod 998244353
using namespace std;
ll n, a[100009], dp[100009];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i];
dp[2] = abs(a[2] - a[1]);
for (int i = 2; i <= n; i++) {
dp[i] =
min(dp[i - 1] + abs(a[i - 1] - a[i]), dp[i - 2] + abs(a[i - 2] - a[i]));
}
cout << dp[n];
}
/*
2
((
)))(
*/
| //#include <bits/stdc++.h>
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string.h>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define ff first
#define ss second
#define ll long long
#define mod 998244353
using namespace std;
ll n, a[100009], dp[100009];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i];
dp[2] = abs(a[2] - a[1]);
for (int i = 3; i <= n; i++) {
dp[i] =
min(dp[i - 1] + abs(a[i - 1] - a[i]), dp[i - 2] + abs(a[i - 2] - a[i]));
}
cout << dp[n];
}
/*
2
((
)))(
*/
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 952,153 | 952,154 | u969825174 | cpp |
p03160 | //#include <bits/stdc++.h>
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string.h>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define ff first
#define ss second
#define ll long long
#define mod 998244353
using namespace std;
int n, a[100009], dp[100009];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i];
dp[2] = abs(a[2] - a[1]);
for (int i = 2; i <= n; i++) {
dp[i] =
min(dp[i - 1] + abs(a[i - 1] - a[i]), dp[i - 2] + abs(a[i - 2] - a[i]));
}
cout << dp[n];
}
/*
2
((
)))(
*/
| //#include <bits/stdc++.h>
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string.h>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define ff first
#define ss second
#define ll long long
#define mod 998244353
using namespace std;
ll n, a[100009], dp[100009];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i];
dp[2] = abs(a[2] - a[1]);
for (int i = 3; i <= n; i++) {
dp[i] =
min(dp[i - 1] + abs(a[i - 1] - a[i]), dp[i - 2] + abs(a[i - 2] - a[i]));
}
cout << dp[n];
}
/*
2
((
)))(
*/
| [
"variable_declaration.type.change",
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 952,155 | 952,154 | u969825174 | cpp |
p03160 | //#include <bits/stdc++.h>
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string.h>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define ff first
#define ss second
#define ll long long
#define mod 998244353
using namespace std;
int n, a[10009], dp[100009];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i];
dp[2] = abs(a[2] - a[1]);
for (int i = 2; i <= n; i++) {
dp[i] =
min(dp[i - 1] + abs(a[i - 1] - a[i]), dp[i - 2] + abs(a[i - 2] - a[i]));
}
cout << dp[n];
}
/*
2
((
)))(
*/
| //#include <bits/stdc++.h>
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string.h>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define ff first
#define ss second
#define ll long long
#define mod 998244353
using namespace std;
ll n, a[100009], dp[100009];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i];
dp[2] = abs(a[2] - a[1]);
for (int i = 3; i <= n; i++) {
dp[i] =
min(dp[i - 1] + abs(a[i - 1] - a[i]), dp[i - 2] + abs(a[i - 2] - a[i]));
}
cout << dp[n];
}
/*
2
((
)))(
*/
| [
"variable_declaration.type.change",
"literal.number.change",
"variable_declaration.array_dimensions.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 952,156 | 952,154 | u969825174 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<long long> vll;
typedef pair<long long, long long> pll;
typedef pair<int, int> pii;
typedef vector<int> vi;
#define deb(x) cout << #x << " : " << x << endl
#define deb2(x, y) cout << #x << " : " << x << " , " << #y << " : " << y << endl
#define rep(i, n) for (int i = 0; i < n; i++)
#define reps(i, a, n) for (int i = a; i < n; i++)
#define rsz(x, n) \
x.clear(); \
x.resize(n)
#define rrsz(x, a, n) \
x.clear(); \
x.resize(n, a)
#define wt while (true)
#define all(x) x.begin(), x.end()
#define pb push_back
#define csl \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
#define s(n) cin >> n
#define ls(x) ((2 * (x)) + 1)
#define rs(x) ((ls(x)) + 1)
#define md(a, b) ((b) + ((a) - (b)) / 2)
#define INF (1e9 + 7)
#define endl '\n'
void solve() {
int n;
cin >> n;
vi h(n), arr(n);
rep(i, n) { cin >> h[i]; }
arr[0] = 0;
arr[1] = h[1] - h[0];
reps(i, 2, n) {
arr[i] = min(arr[i - 1] + abs(h[i] - h[i - 1]),
arr[i - 2] + abs(h[i] - h[i - 2]));
}
cout << arr[n - 1];
}
int main() {
csl;
int testcase = 1;
// cin >> testcase;
for (int i = 0; i < testcase; i++) {
solve();
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<long long> vll;
typedef pair<long long, long long> pll;
typedef pair<int, int> pii;
typedef vector<int> vi;
#define deb(x) cout << #x << " : " << x << endl
#define deb2(x, y) cout << #x << " : " << x << " , " << #y << " : " << y << endl
#define rep(i, n) for (int i = 0; i < n; i++)
#define reps(i, a, n) for (int i = a; i < n; i++)
#define rsz(x, n) \
x.clear(); \
x.resize(n)
#define rrsz(x, a, n) \
x.clear(); \
x.resize(n, a)
#define wt while (true)
#define all(x) x.begin(), x.end()
#define pb push_back
#define csl \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
#define s(n) cin >> n
#define ls(x) ((2 * (x)) + 1)
#define rs(x) ((ls(x)) + 1)
#define md(a, b) ((b) + ((a) - (b)) / 2)
#define INF (1e9 + 7)
#define endl '\n'
void solve() {
int n;
cin >> n;
vll h(n), arr(n);
rep(i, n) { cin >> h[i]; }
arr[0] = 0;
arr[1] = abs(h[1] - h[0]);
reps(i, 2, n) {
arr[i] = min(arr[i - 1] + abs(h[i] - h[i - 1]),
arr[i - 2] + abs(h[i] - h[i - 2]));
}
cout << arr[n - 1];
}
int main() {
csl;
int testcase = 1;
// cin >> testcase;
for (int i = 0; i < testcase; i++) {
solve();
}
return 0;
}
| [
"variable_declaration.type.change",
"call.add",
"call.arguments.change"
] | 952,159 | 952,160 | u105054381 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i <= n - 1; i++) {
cin >> a[i];
}
int dp[n + 1];
memset(dp, 0, sizeof(dp));
dp[0] = a[0];
dp[1] = abs(a[0] - a[1]);
for (int i = 2; i <= n - 1; i++) {
dp[i] =
min(dp[i - 1] + abs(a[i] - a[i - 1]), dp[i - 2] + abs(a[i] - a[i - 2]));
}
cout << dp[n - 1];
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i <= n - 1; i++) {
cin >> a[i];
}
int dp[n + 1];
memset(dp, 0, sizeof(dp));
dp[0] = 0;
dp[1] = abs(a[0] - a[1]);
for (int i = 2; i <= n - 1; i++) {
dp[i] =
min(dp[i - 1] + abs(a[i] - a[i - 1]), dp[i - 2] + abs(a[i] - a[i - 2]));
}
// for ( int i = 0; i<= n-1; i++)
// cout<<dp[i]<<' ';
cout << dp[n - 1];
}
| [] | 952,166 | 952,167 | u752731990 | cpp |
p03160 | // Created by SAMAN on ۷/۳۱/۲۰۲۰ م..
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <set>
#include <vector>
#define lint long long int
#define kill(x) return cout << x << '\n', 0;
#define debug(x) cout << #x << " : " << x << '\n'
#define pb push_back
#define ppb pop_back
using namespace std;
int n;
const int maxn = 1e5;
int a[maxn];
int dp[maxn];
int main() {
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i];
dp[1] = a[1];
dp[2] = abs(a[2] - a[1]);
for (int i = 3; i <= n; i++)
dp[i] =
min(abs(a[i - 1] - a[i]) + dp[i - 1], abs(a[i - 2] - a[i]) + dp[i - 2]);
cout << dp[n];
} | // Created by SAMAN on ۷/۳۱/۲۰۲۰ م..
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <set>
#include <vector>
#define lint long long int
#define kill(x) return cout << x << '\n', 0;
#define debug(x) cout << #x << " : " << x << '\n'
#define pb push_back
#define ppb pop_back
using namespace std;
int n;
const int maxn = 1e5;
int a[maxn];
int dp[maxn];
int main() {
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i];
dp[1] = 0;
dp[2] = abs(a[2] - a[1]);
for (int i = 3; i <= n; i++)
dp[i] =
min(abs(a[i - 1] - a[i]) + dp[i - 1], abs(a[i - 2] - a[i]) + dp[i - 2]);
cout << dp[n];
} | [
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add"
] | 952,176 | 952,177 | u430255348 | cpp |
p03160 | #include <iostream>
using namespace std;
int main() {
int n, i;
cin >> n;
int h[n];
for (i = 1; i <= n; i++) {
cin >> h[i];
}
int dp[n + 1];
dp[1] = 0;
dp[2] = abs(h[2] - h[1]) + dp[1];
for (i = 3; i < n; i++) {
dp[i] =
min(abs(h[i] - h[i - 1]) + dp[i - 1], abs(h[i] - h[i - 2]) + dp[i - 2]);
}
cout << dp[n];
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n, i;
cin >> n;
int h[n + 1];
for (i = 1; i <= n; i++) {
cin >> h[i];
}
int dp[n + 1];
dp[1] = 0;
dp[2] = abs(h[2] - h[1]) + dp[1];
for (i = 3; i <= n; i++) {
dp[i] =
min(abs(h[i] - h[i - 1]) + dp[i - 1], abs(h[i] - h[i - 2]) + dp[i - 2]);
}
cout << dp[n];
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 952,180 | 952,181 | u352310516 | cpp |
p03160 | #include <iostream>
using namespace std;
int main() {
int n, i;
cin >> n;
int h[n];
for (i = 0; i < n; i++) {
cin >> h[i];
}
int dp[n + 1];
dp[1] = 0;
dp[2] = abs(h[2] - h[1]) + dp[1];
for (i = 3; i < n; i++) {
dp[i] =
min(abs(h[i] - h[i - 1]) + dp[i - 1], abs(h[i] - h[i - 2]) + dp[i - 2]);
}
cout << dp[n];
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n, i;
cin >> n;
int h[n + 1];
for (i = 1; i <= n; i++) {
cin >> h[i];
}
int dp[n + 1];
dp[1] = 0;
dp[2] = abs(h[2] - h[1]) + dp[1];
for (i = 3; i <= n; i++) {
dp[i] =
min(abs(h[i] - h[i - 1]) + dp[i - 1], abs(h[i] - h[i - 2]) + dp[i - 2]);
}
cout << dp[n];
return 0;
} | [
"literal.number.change",
"assignment.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"
] | 952,182 | 952,181 | u352310516 | cpp |
p03160 | #include <iostream>
using namespace std;
int main() {
int n, i;
cin >> n;
int h[n];
for (i = 0; i < n; i++) {
cin >> h[i];
}
int dp[n - 1];
dp[1] = 0;
dp[2] = abs(h[2] - h[1]) + dp[1];
for (i = 3; i < n; i++) {
dp[i] =
min(abs(h[i] - h[i - 1]) + dp[i - 1], abs(h[i] - h[i - 2]) + dp[i - 2]);
}
cout << dp[n];
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n, i;
cin >> n;
int h[n + 1];
for (i = 1; i <= n; i++) {
cin >> h[i];
}
int dp[n + 1];
dp[1] = 0;
dp[2] = abs(h[2] - h[1]) + dp[1];
for (i = 3; i <= n; i++) {
dp[i] =
min(abs(h[i] - h[i - 1]) + dp[i - 1], abs(h[i] - h[i - 2]) + dp[i - 2]);
}
cout << dp[n];
return 0;
} | [
"literal.number.change",
"assignment.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",
"misc.opposites",
"expression.operator.arithmetic.change"
] | 952,183 | 952,181 | u352310516 | cpp |
p03160 | #include <algorithm>
#include <iostream>
#include <limits>
int main() {
int N;
std::cin >> N;
int h[N];
for (int i = 0; i < N; ++i) {
std::cin >> h[i];
}
int dp[N];
for (int i = 0; i < N; ++i) {
dp[i] = std::numeric_limits<int>::max();
}
dp[0] = 0;
dp[1] = abs(h[0] - h[1]);
for (int i = 2; i < N; ++i) {
dp[i] = std::min(dp[i - 1] + abs(h[i] - h[i - 1]),
dp[i - 2] + abs(h[i] - h[i - 2]));
}
std::cout << h[N - 1];
return 0;
} | #include <algorithm>
#include <iostream>
#include <limits>
int main() {
int N;
std::cin >> N;
int h[N];
for (int i = 0; i < N; ++i) {
std::cin >> h[i];
}
int dp[N];
for (int i = 0; i < N; ++i) {
dp[i] = std::numeric_limits<int>::max();
}
dp[0] = 0;
dp[1] = abs(h[0] - h[1]);
for (int i = 2; i < N; ++i) {
dp[i] = std::min(dp[i - 1] + std::abs(h[i] - h[i - 1]),
dp[i - 2] + std::abs(h[i] - h[i - 2]));
}
std::cout << dp[N - 1];
return 0;
}
| [
"identifier.change",
"expression.operation.binary.change"
] | 952,184 | 952,185 | u587370992 | cpp |
p03160 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define int long long
int n;
int a[100005];
int dp[100005];
int fun(int ind) {
if (ind == (n - 1))
return 0;
if (ind >= n)
return INT_MAX;
if (dp[ind] != -1)
return dp[ind];
int left = abs(a[ind] - a[ind + 1]) + fun(ind + 1);
int right = INT_MAX;
if (ind + 2 < n) {
right = abs(a[ind] - a[ind + 2]) + fun(ind + 2);
}
return dp[ind] = min(left, right);
}
signed main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
memset(dp, -1, n);
cout << fun(0);
// return 0;
}
| #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define int long long
int n;
int a[100005];
int dp[100005];
int fun(int ind) {
if (ind == (n - 1))
return 0;
if (ind >= n)
return INT_MAX;
if (dp[ind] != -1)
return dp[ind];
int left = abs(a[ind] - a[ind + 1]) + fun(ind + 1);
int right = INT_MAX;
if (ind + 2 < n) {
right = abs(a[ind] - a[ind + 2]) + fun(ind + 2);
}
return dp[ind] = min(left, right);
}
signed main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
memset(dp, -1, sizeof dp);
cout << fun(0);
// return 0;
}
| [
"call.arguments.change"
] | 952,190 | 952,191 | u444171208 | 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] = abs(arr[1] - arr[2]);
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] << "\n";
} | #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++) {
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] << "\n";
} | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 952,194 | 952,195 | u962049952 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define gc getchar_unlocked
#define f(n) for (int i = 0; i < n; i++)
#define fo(i, n) for (i = 0; i < n; i++)
#define Fo(k, n) for (int i = k; k < n ? i < n : i > n; k < n ? i += 1 : i -= 1)
#define ll long long
#define si(x) scanf("%d", &x)
#define sl(x) scanf("%lld", &x)
#define ss(s) scanf("%s", s)
#define pi(x) printf("%d\n", x)
#define pl(x) printf("%lld\n", x)
#define ps(s) printf("%s\n", s)
#define deb(x) cout << #x << "=" << x << endl
#define deb2(x, y) cout << #x << "=" << x << "," << #y << "=" << y << endl
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define F first
#define S second
#define all(x) x.begin(), x.end()
#define clr(x) memset(x, 0, sizeof(x))
#define sortall(x) sort(all(x))
#define tr(it, a) for (auto it = a.begin(); it != a.end(); it++)
#define PI 3.1415926535897932384626
#define OJ \
freopen("input.txt", "r", stdin); \
freopen("output.txt", "w", stdout);
typedef pair<int, int> pii;
typedef pair<ll, ll> pl;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<pii> vpii;
typedef vector<pl> vpl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
const int mod = 1'000'000'007;
const int N = 3e5, M = N;
//=======================
void solve() {
int n, e;
cin >> n;
vi a, r = {0};
for (int i = 0; i < n; i++)
cin >> e, a.emplace_back(e);
r.emplace_back(abs(a[0] - a[1]));
for (int i = 2; i < n; i++)
r.emplace_back(
min(r[i - 2] + abs(a[i] - a[i - 2]), r[i - 1] + abs(a[i - 1] - a[i])));
cout << r[n - 1];
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
OJ;
// clock_t start,stop;
// start=clock();
int t = 1;
// cin >> t;
while (t--) {
solve();
}
// stop=clock();
// cout<<endl<<stop-start<<"ms";
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define gc getchar_unlocked
#define f(n) for (int i = 0; i < n; i++)
#define fo(i, n) for (i = 0; i < n; i++)
#define Fo(k, n) for (int i = k; k < n ? i < n : i > n; k < n ? i += 1 : i -= 1)
#define ll long long
#define si(x) scanf("%d", &x)
#define sl(x) scanf("%lld", &x)
#define ss(s) scanf("%s", s)
#define pi(x) printf("%d\n", x)
#define pl(x) printf("%lld\n", x)
#define ps(s) printf("%s\n", s)
#define deb(x) cout << #x << "=" << x << endl
#define deb2(x, y) cout << #x << "=" << x << "," << #y << "=" << y << endl
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define F first
#define S second
#define all(x) x.begin(), x.end()
#define clr(x) memset(x, 0, sizeof(x))
#define sortall(x) sort(all(x))
#define tr(it, a) for (auto it = a.begin(); it != a.end(); it++)
#define PI 3.1415926535897932384626
#define OJ \
freopen("input.txt", "r", stdin); \
freopen("output.txt", "w", stdout);
typedef pair<int, int> pii;
typedef pair<ll, ll> pl;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<pii> vpii;
typedef vector<pl> vpl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
const int mod = 1'000'000'007;
const int N = 3e5, M = N;
//=======================
void solve() {
int n, e;
cin >> n;
vi a, r = {0};
for (int i = 0; i < n; i++)
cin >> e, a.emplace_back(e);
r.emplace_back(abs(a[0] - a[1]));
for (int i = 2; i < n; i++)
r.emplace_back(
min(r[i - 2] + abs(a[i] - a[i - 2]), r[i - 1] + abs(a[i - 1] - a[i])));
cout << r[n - 1];
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
// OJ;
// clock_t start,stop;
// start=clock();
int t = 1;
// cin >> t;
while (t--) {
solve();
}
// stop=clock();
// cout<<endl<<stop-start<<"ms";
return 0;
} | [] | 952,200 | 952,201 | u653928018 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
const int mxn = 1e5;
int dp[mxn + 2];
int h[mxn + 2];
int func(int n) {
int k;
if (n == 1)
return dp[1] = 0;
if (dp[n] != -1)
return dp[n];
dp[n] = func(n - 1) + abs(h[n] - h[n - 1]);
if (n > 2) {
k = func(n - 2) + abs(h[n] - h[n - 2]);
}
dp[n] = min(k, dp[n]);
return dp[n];
}
int main() {
memset(dp, -1, sizeof(dp));
int n;
cin >> n;
for (int i = 0; i < n; i++)
cin >> h[i + 1];
cout << func(n) << endl;
} | #include <bits/stdc++.h>
using namespace std;
const int mxn = 1e5;
int dp[mxn + 2];
int h[mxn + 2];
int func(int n) {
int k;
if (n == 1)
return dp[1] = 0;
if (dp[n] != -1)
return dp[n];
dp[n] = func(n - 1) + abs(h[n] - h[n - 1]);
if (n > 2) {
k = func(n - 2) + abs(h[n] - h[n - 2]);
dp[n] = min(k, dp[n]);
}
return dp[n];
}
int main() {
memset(dp, -1, sizeof(dp));
int n;
cin >> n;
for (int i = 0; i < n; i++)
cin >> h[i + 1];
cout << func(n) << endl;
} | [] | 952,202 | 952,203 | u209384203 | cpp |
p03160 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <queue>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define vi vector<int>
#define vb vector<bool>
#define lli long long int
#define vvi vector<vector<int>>
#define loop(n) for (int i = 0; i < n; i++)
using namespace std;
auto SpeedUp = []() {
std::ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
return 0;
}();
int solve() {
int n;
cin >> n;
vi arr(n, 0);
loop(n) cin >> arr[i];
vi dp(n, 0);
dp[n - 2] = abs(arr[n - 1] - arr[n - 1]);
for (int i = n - 3; i >= 0; i--) {
dp[i] = min(dp[i + 1] + abs(arr[i + 1] - arr[i]),
dp[i + 2] + abs(arr[i + 2] - arr[i]));
}
return dp[0];
}
int main() {
cout << solve() << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <queue>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define vi vector<int>
#define vb vector<bool>
#define lli long long int
#define vvi vector<vector<int>>
#define loop(n) for (int i = 0; i < n; i++)
using namespace std;
auto SpeedUp = []() {
std::ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
return 0;
}();
int solve() {
int n;
cin >> n;
vi arr(n, 0);
loop(n) cin >> arr[i];
vi dp(n, 0);
dp[n - 2] = abs(arr[n - 2] - arr[n - 1]);
for (int i = n - 3; i >= 0; i--) {
dp[i] = min(dp[i + 1] + abs(arr[i + 1] - arr[i]),
dp[i + 2] + abs(arr[i + 2] - arr[i]));
}
// for(int ele :dp)
// cout << ele << " ";
return dp[0];
}
int main() {
cout << solve() << endl;
return 0;
} | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 952,204 | 952,205 | u911189808 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int dp[N], a[N], n;
int main() {
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i];
dp[0] = 0;
dp[1] = 0;
for (int i = 2; i <= n; i++) {
dp[i] = dp[i - 1] + abs(a[i] - a[i - 1]);
if (i > 2) {
dp[i] = min(dp[i], dp[i - 2] + abs(a[i]) - a[i - 2]);
}
}
cout << dp[n] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int dp[N], a[N], n;
int main() {
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i];
dp[0] = 0;
dp[1] = 0;
for (int i = 2; i <= n; i++) {
dp[i] = dp[i - 1] + abs(a[i] - a[i - 1]);
if (i > 2) {
dp[i] = min(dp[i], dp[i - 2] + abs(a[i] - a[i - 2]));
}
}
cout << dp[n] << endl;
return 0;
} | [
"call.arguments.change"
] | 952,206 | 952,207 | u564843244 | cpp |
p03160 | #include <bits/stdc++.h>
#define ll long long int
using namespace std;
ll frog(vector<ll> h, vector<ll> dp, ll n) {
for (int i = 1; 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 + 1] - h[i - 1]));
}
return dp[n];
}
/*ll fg(vector<ll> h,vector<ll> dp,ll n){
if(n==1)return 0;
else if(n==2)return abs(h[1]-h[0]);
dp[n]+=min(dp[])
}*/
int main() {
ll n;
cin >> n;
vector<ll> h(n), dp(n + 4, 1000000);
dp[0] = 0;
dp[1] = 0;
for (int i = 0; i < n; i++)
cin >> h[i];
cout << frog(h, dp, n) << "\n";
return 0;
}
| #include <bits/stdc++.h>
#define ll long long int
using namespace std;
ll frog(vector<ll> h, vector<ll> dp, ll n) {
for (int i = 1; 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 + 1] - h[i - 1]));
}
return dp[n];
}
/*ll fg(vector<ll> h,vector<ll> dp,ll n){
if(n==1)return 0;
else if(n==2)return abs(h[1]-h[0]);
dp[n]+=min(dp[])
}*/
int main() {
ll n;
cin >> n;
vector<ll> h(n), dp(n + 4, INT_MAX);
dp[0] = 0;
dp[1] = 0;
for (int i = 0; i < n; i++)
cin >> h[i];
cout << frog(h, dp, n) << "\n";
return 0;
}
| [
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change"
] | 952,212 | 952,213 | u987274574 | cpp |
p03160 | #include <bits/stdc++.h>
#define ll long long int
using namespace std;
ll frog(vector<ll> h, vector<ll> dp, ll n) {
for (int i = 1; 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 + 1] - h[i - 1]));
}
return dp[n];
}
/*ll fg(vector<ll> h,vector<ll> dp,ll n){
if(n==1)return 0;
else if(n==2)return abs(h[1]-h[0]);
dp[n]+=min(dp[])
}*/
int main() {
ll n;
cin >> n;
vector<ll> h(n), dp(n + 4, 100);
dp[0] = 0;
dp[1] = 0;
for (int i = 0; i < n; i++)
cin >> h[i];
cout << frog(h, dp, n) << "\n";
return 0;
}
| #include <bits/stdc++.h>
#define ll long long int
using namespace std;
ll frog(vector<ll> h, vector<ll> dp, ll n) {
for (int i = 1; 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 + 1] - h[i - 1]));
}
return dp[n];
}
/*ll fg(vector<ll> h,vector<ll> dp,ll n){
if(n==1)return 0;
else if(n==2)return abs(h[1]-h[0]);
dp[n]+=min(dp[])
}*/
int main() {
ll n;
cin >> n;
vector<ll> h(n), dp(n + 4, INT_MAX);
dp[0] = 0;
dp[1] = 0;
for (int i = 0; i < n; i++)
cin >> h[i];
cout << frog(h, dp, n) << "\n";
return 0;
}
| [
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change"
] | 952,214 | 952,213 | u987274574 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> h(n);
for (int i = 0; i < n; i++) {
cin >> h[i];
}
vector<int> dp(n);
dp[0] = h[0];
dp[1] = abs(dp[0] - 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 - 1] << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> h(n);
for (int i = 0; i < n; i++) {
cin >> h[i];
}
vector<int> dp(n);
dp[0] = 0;
dp[1] = abs(h[0] - 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 - 1] << endl;
}
| [
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 952,215 | 952,216 | u204158532 | cpp |
p03160 | #include <bits/stdc++.h>
#define de(x) cout << #x << "=" << x << ", "
#define dd cout << '\n';
#define Eriri ios::sync_with_stdio(0), cin.tie(0);
#define F first
#define S second
#define int long long
using namespace std;
typedef pair<int, int> Pii;
const int N = 1e5 + 10;
int dp[N], n, h[N];
signed main() {
Eriri cin >> n;
for (int i = 1; i <= n; i++)
cin >> h[i];
dp[n - 1] = abs(h[n] - h[n - 1]);
for (int i = n - 1; i > 0; i--) {
dp[i] =
min(dp[i + 1] + abs(h[i] - h[i + 1]), dp[i + 2] + abs(h[i] - h[i + 2]));
}
cout << dp[1] << '\n';
} | #include <bits/stdc++.h>
#define de(x) cout << #x << "=" << x << ", "
#define dd cout << '\n';
#define Eriri ios::sync_with_stdio(0), cin.tie(0);
#define F first
#define S second
#define int long long
using namespace std;
typedef pair<int, int> Pii;
const int N = 1e5 + 10;
int dp[N], n, h[N];
signed main() {
Eriri cin >> n;
for (int i = 1; i <= n; i++)
cin >> h[i];
dp[n - 1] = abs(h[n] - h[n - 1]);
for (int i = n - 2; i > 0; i--) {
dp[i] =
min(dp[i + 1] + abs(h[i] - h[i + 1]), dp[i + 2] + abs(h[i] - h[i + 2]));
}
cout << dp[1] << '\n';
} | [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 952,217 | 952,218 | u840424904 | cpp |
p03160 | #include <bits/stdc++.h>
#define de(x) cout << #x << "=" << x << ", "
#define dd cout << '\n';
#define Eriri ios::sync_with_stdio(0), cin.tie(0);
#define F first
#define S second
#define int long long
using namespace std;
typedef pair<int, int> Pii;
const int N = 1e5 + 10;
int dp[N], n, h[N];
signed main() {
Eriri cin >> n;
for (int i = 1; i <= n; i++)
cin >> h[i];
dp[n - 1] = abs(h[n] - h[n + 1]);
for (int i = n - 1; i > 0; i--) {
dp[i] =
min(dp[i + 1] + abs(h[i] - h[i + 1]), dp[i + 2] + abs(h[i] - h[i + 2]));
}
cout << dp[1] << '\n';
} | #include <bits/stdc++.h>
#define de(x) cout << #x << "=" << x << ", "
#define dd cout << '\n';
#define Eriri ios::sync_with_stdio(0), cin.tie(0);
#define F first
#define S second
#define int long long
using namespace std;
typedef pair<int, int> Pii;
const int N = 1e5 + 10;
int dp[N], n, h[N];
signed main() {
Eriri cin >> n;
for (int i = 1; i <= n; i++)
cin >> h[i];
dp[n - 1] = abs(h[n] - h[n - 1]);
for (int i = n - 2; i > 0; i--) {
dp[i] =
min(dp[i + 1] + abs(h[i] - h[i + 1]), dp[i + 2] + abs(h[i] - h[i + 2]));
}
cout << dp[1] << '\n';
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change",
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 952,219 | 952,218 | u840424904 | cpp |
p03160 | #include <bits/stdc++.h>
#define de(x) cout << #x << "=" << x << ", "
#define dd cout << '\n';
#define Eriri ios::sync_with_stdio(0), cin.tie(0);
#define F first
#define S second
#define int long long
using namespace std;
typedef pair<int, int> Pii;
const int N = 1e5 + 10;
int dp[N], n, h[N];
signed main() {
Eriri cin >> n;
for (int i = 1; i <= n; i++)
cin >> h[i];
dp[n - 1] = h[n] - h[n + 1];
for (int i = n - 1; i > 0; i--) {
dp[i] =
min(dp[i + 1] + abs(h[i] - h[i + 1]), dp[i + 2] + abs(h[i] - h[i + 2]));
}
cout << dp[1] << '\n';
} | #include <bits/stdc++.h>
#define de(x) cout << #x << "=" << x << ", "
#define dd cout << '\n';
#define Eriri ios::sync_with_stdio(0), cin.tie(0);
#define F first
#define S second
#define int long long
using namespace std;
typedef pair<int, int> Pii;
const int N = 1e5 + 10;
int dp[N], n, h[N];
signed main() {
Eriri cin >> n;
for (int i = 1; i <= n; i++)
cin >> h[i];
dp[n - 1] = abs(h[n] - h[n - 1]);
for (int i = n - 2; i > 0; i--) {
dp[i] =
min(dp[i + 1] + abs(h[i] - h[i + 1]), dp[i + 2] + abs(h[i] - h[i + 2]));
}
cout << dp[1] << '\n';
} | [
"call.add",
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change",
"call.arguments.change",
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 952,220 | 952,218 | u840424904 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int h[n];
int dp[n];
for (int i = 0; i < n; i++)
cin >> h[i];
dp[0] = h[0];
dp[1] = abs(h[0] - h[1]);
for (int i = 2; i < n; i++) {
dp[i] =
min(dp[i - 2] + abs(h[i] - h[i - 2]), dp[i - 1] + abs(h[i] - h[i - 1]));
}
cout << dp[n - 1];
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int h[n];
int dp[n];
for (int i = 0; i < n; i++)
cin >> h[i];
dp[0] = 0;
dp[1] = abs(h[0] - h[1]);
for (int i = 2; i < n; i++) {
dp[i] =
min(dp[i - 2] + abs(h[i] - h[i - 2]), dp[i - 1] + abs(h[i] - h[i - 1]));
}
cout << dp[n - 1];
return 0;
} | [] | 952,223 | 952,224 | u968930840 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int solve(vector<int> &a, int i, int n, vector<int> &dp) {
if (i == n) {
return 0;
}
if (dp[i] != -1) {
return dp[i];
}
int c1 = INT_MAX;
int c2 = INT_MAX;
if (i + 1 <= n) {
c1 = abs(a[i + 1] - a[i]) + solve(a, i + 1, n, dp);
}
if (i + 2 <= n) {
c1 = abs(a[i + 2] - a[i]) + solve(a, i + 2, n, dp);
}
return dp[i] = min(c1, c2);
}
int main() {
int n;
cin >> n;
vector<int> a(n + 1, 0);
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
vector<int> dp(n + 1, -1);
cout << solve(a, 1, n, dp);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int solve(vector<int> &a, int i, int n, vector<int> &dp) {
if (i == n) {
return 0;
}
if (dp[i] != -1) {
return dp[i];
}
int c1 = INT_MAX;
int c2 = INT_MAX;
if (i + 1 <= n) {
c1 = abs(a[i + 1] - a[i]) + solve(a, i + 1, n, dp);
}
if (i + 2 <= n) {
c2 = abs(a[i + 2] - a[i]) + solve(a, i + 2, n, dp);
}
return dp[i] = min(c1, c2);
}
int main() {
int n;
cin >> n;
vector<int> a(n + 1, 0);
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
vector<int> dp(n + 1, -1);
cout << solve(a, 1, n, dp);
return 0;
}
| [
"assignment.variable.change",
"identifier.change"
] | 952,225 | 952,226 | u617710640 | cpp |
p03160 | /*╔═══╗──╔╗╔╗───────────────────╔╗────────╔═══╦═══╗
║║─║╠╗╠╗╔╣╚═╦══╦═╗╔╦╗╔═╗╔══╦══╣╚═╦╦══╦══╣║─║║║─╚╝
║╔═╗║╚╝║╚╣║║║╚╝║║─╔╦╗║║║║╚╝║╚╝║╚╝║║║═╬══║╔═╗║╚╩═║
╚╝─╚╩══╩═╩╝╚╩══╩╝─╚╩╝╚╝╚╩══╩══╩══╩╩══╩══╩╝─╚╩═══╝*/
#include <bits/stdc++.h>
/*
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pdbs;
template <typename T> using ordered_set = tree<T, null_type, less<T>,
rb_tree_tag, tree_order_statistics_node_update>;
1. order_of_key(k) : number of elements strictly lesser than k
2. find_by_order(k) : k-th element in the set
*/
//#define int long long
using namespace std;
#define f(i, k, n) for (i = k; i < n; i++)
#define fd(i, k, n) for (i = k; i > n; i--)
#define pb push_back
#define mp make_pair
#define ll long long
#define ld long double
#define ull unsigned long long
#define vi vector<int>
#define vll vector<ll>
#define vvi vector<vi>
#define vvll vector<vll>
#define pii pair<int, int>
#define pll pair<ll, ll>
#define mii map<int, int>
#define mll map<ll, ll>
#define umap unordered_map
#define all(c) c.begin(), c.end()
#define sz(c) (int)c.size()
#define si(c) (int)c.size()
#define lb lower_bound
#define ub upper_bound
#define gi greater<int>
#define rev reverse
#define ff first
#define ss second
#define yes cout << "YES" << endl
#define no cout << "NO" << endl
#define imp cout << "IMPOSSIBLE" << endl
#define nl cout << endl
#define hello cout << "hello" << endl
#define sp(x) fixed << setprecision(x)
#define re return
#define p_q priority_queue
#define FAST \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
// debugging
void dbg_out() { cerr << endl; }
template <typename Head, typename... Tail> void dbg_out(Head H, Tail... T) {
cerr << ' ' << H;
dbg_out(T...);
}
#define dbg(...) cerr << "(" << #__VA_ARGS__ << "):", dbg_out(__VA_ARGS__)
const double pi = 3.14159265359;
const ll mod = 1000000007;
const ll modc = 998244353;
ll inline power(ll a, ll b, ll p) {
a %= p;
ll ans = 1;
while (b > 0) {
if (b & 1)
ans = (ans * a) % p;
a = (a * a) % p;
b >>= 1;
}
return ans;
}
ll mod_inv(ll n, ll p) { return power(n, p - 2, p); }
bool inline isPrime(ll n) {
if (n <= 1)
return false;
if (n <= 3)
return true;
if (n % 2 == 0 || n % 3 == 0)
return false;
for (ll i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
template <typename... T> void W(T &&...args) {
((cout << sp(9) << args << " "), ...);
nl;
}
template <typename... T> void R(T &&...args) { ((cin >> args), ...); }
ll ston(string s) {
ll a = 0;
reverse(s.begin(), s.end());
ll pow = 1;
for (int i = 0; i < s.size(); i++) {
a += pow * (s[i] - '0');
pow *= 10;
}
return a;
}
template <class T> string to_binary(T n) {
string binaryNum;
int i = 0;
while (n > 0) {
binaryNum.pb((n % 2) + '0');
n = n / 2;
i++;
}
reverse(binaryNum.begin(), binaryNum.end());
return binaryNum;
}
template <class T> void wv(T &v) {
for (auto x : v)
cout << x << " ";
nl;
}
template <class T> void rv(T &v) {
for (int i = 0; i < sz(v); i++)
cin >> v[i];
}
// to safe_guard unordered_map<> in STL
// now declare something as unordered_map<int,int,custom_hash>mp :)
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
// http://xorshift.di.unimi.it/splitmix64.c
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
/*
* USING WITH STRUCT
Define a structure .
Initialize variables in structure.
Define another structure of type compare.(don't use bool operator < for stl
containers (since it is there in std namespace); Overload the variables of
structure in compare structure.(bool operator()(arguments){} ) Use container
with compare structure. (priority queue me ulta)
*/
/*
FUNCTIONS YOU ARE USING
* ll inline power(ll a, ll b, ll p)
* ll mod_inv(ll n, ll p)
* bool inline isPrime(ll n)
* ll ston(string s)
* string to_binary(T n)
*/
/*
*int overflow (ll vs int)
*array out of bounds(runtime errors)
*special cases (n=1)?
*don't store large numbers in double(use long double instead)
*BINARY SEARCH ??
*BRUTE FORCE with some optimization ??
*in compare return true if you want to place first argument before second
*argument(p_q me ulta)(bool operator<)(bool operator()) Use custom_hash with
*unordered_map to avoid collisions Think of your approach for one more minute
*if it will work or not , otherwise you will end up implementing shit as always
*:( use factor cmd to get prime factorization of something instead of writing
*another code for it :) DO SOMETHING INSTEAD OF NOTHING
*/
const int M = 2e5; // for graph
void solve() {
int i, j;
ll sum = 0, prod = 1;
ll maxl = LLONG_MIN, minl = LLONG_MAX;
int maxi = INT_MIN, mini = INT_MAX;
int n;
cin >> n;
vi h(n);
rv(h);
vector<int> dp(n);
dp[0] = h[0];
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]));
cout << dp[n - 1] << endl;
}
int32_t main() {
FAST;
int t = 1;
while (t--) {
solve();
}
}
| /*╔═══╗──╔╗╔╗───────────────────╔╗────────╔═══╦═══╗
║║─║╠╗╠╗╔╣╚═╦══╦═╗╔╦╗╔═╗╔══╦══╣╚═╦╦══╦══╣║─║║║─╚╝
║╔═╗║╚╝║╚╣║║║╚╝║║─╔╦╗║║║║╚╝║╚╝║╚╝║║║═╬══║╔═╗║╚╩═║
╚╝─╚╩══╩═╩╝╚╩══╩╝─╚╩╝╚╝╚╩══╩══╩══╩╩══╩══╩╝─╚╩═══╝*/
#include <bits/stdc++.h>
/*
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pdbs;
template <typename T> using ordered_set = tree<T, null_type, less<T>,
rb_tree_tag, tree_order_statistics_node_update>;
1. order_of_key(k) : number of elements strictly lesser than k
2. find_by_order(k) : k-th element in the set
*/
//#define int long long
using namespace std;
#define f(i, k, n) for (i = k; i < n; i++)
#define fd(i, k, n) for (i = k; i > n; i--)
#define pb push_back
#define mp make_pair
#define ll long long
#define ld long double
#define ull unsigned long long
#define vi vector<int>
#define vll vector<ll>
#define vvi vector<vi>
#define vvll vector<vll>
#define pii pair<int, int>
#define pll pair<ll, ll>
#define mii map<int, int>
#define mll map<ll, ll>
#define umap unordered_map
#define all(c) c.begin(), c.end()
#define sz(c) (int)c.size()
#define si(c) (int)c.size()
#define lb lower_bound
#define ub upper_bound
#define gi greater<int>
#define rev reverse
#define ff first
#define ss second
#define yes cout << "YES" << endl
#define no cout << "NO" << endl
#define imp cout << "IMPOSSIBLE" << endl
#define nl cout << endl
#define hello cout << "hello" << endl
#define sp(x) fixed << setprecision(x)
#define re return
#define p_q priority_queue
#define FAST \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
// debugging
void dbg_out() { cerr << endl; }
template <typename Head, typename... Tail> void dbg_out(Head H, Tail... T) {
cerr << ' ' << H;
dbg_out(T...);
}
#define dbg(...) cerr << "(" << #__VA_ARGS__ << "):", dbg_out(__VA_ARGS__)
const double pi = 3.14159265359;
const ll mod = 1000000007;
const ll modc = 998244353;
ll inline power(ll a, ll b, ll p) {
a %= p;
ll ans = 1;
while (b > 0) {
if (b & 1)
ans = (ans * a) % p;
a = (a * a) % p;
b >>= 1;
}
return ans;
}
ll mod_inv(ll n, ll p) { return power(n, p - 2, p); }
bool inline isPrime(ll n) {
if (n <= 1)
return false;
if (n <= 3)
return true;
if (n % 2 == 0 || n % 3 == 0)
return false;
for (ll i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
template <typename... T> void W(T &&...args) {
((cout << sp(9) << args << " "), ...);
nl;
}
template <typename... T> void R(T &&...args) { ((cin >> args), ...); }
ll ston(string s) {
ll a = 0;
reverse(s.begin(), s.end());
ll pow = 1;
for (int i = 0; i < s.size(); i++) {
a += pow * (s[i] - '0');
pow *= 10;
}
return a;
}
template <class T> string to_binary(T n) {
string binaryNum;
int i = 0;
while (n > 0) {
binaryNum.pb((n % 2) + '0');
n = n / 2;
i++;
}
reverse(binaryNum.begin(), binaryNum.end());
return binaryNum;
}
template <class T> void wv(T &v) {
for (auto x : v)
cout << x << " ";
nl;
}
template <class T> void rv(T &v) {
for (int i = 0; i < sz(v); i++)
cin >> v[i];
}
// to safe_guard unordered_map<> in STL
// now declare something as unordered_map<int,int,custom_hash>mp :)
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
// http://xorshift.di.unimi.it/splitmix64.c
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
/*
* USING WITH STRUCT
Define a structure .
Initialize variables in structure.
Define another structure of type compare.(don't use bool operator < for stl
containers (since it is there in std namespace); Overload the variables of
structure in compare structure.(bool operator()(arguments){} ) Use container
with compare structure. (priority queue me ulta)
*/
/*
FUNCTIONS YOU ARE USING
* ll inline power(ll a, ll b, ll p)
* ll mod_inv(ll n, ll p)
* bool inline isPrime(ll n)
* ll ston(string s)
* string to_binary(T n)
*/
/*
*int overflow (ll vs int)
*array out of bounds(runtime errors)
*special cases (n=1)?
*don't store large numbers in double(use long double instead)
*BINARY SEARCH ??
*BRUTE FORCE with some optimization ??
*in compare return true if you want to place first argument before second
*argument(p_q me ulta)(bool operator<)(bool operator()) Use custom_hash with
*unordered_map to avoid collisions Think of your approach for one more minute
*if it will work or not , otherwise you will end up implementing shit as always
*:( use factor cmd to get prime factorization of something instead of writing
*another code for it :) DO SOMETHING INSTEAD OF NOTHING
*/
const int M = 2e5; // for graph
void solve() {
int i, j;
ll sum = 0, prod = 1;
ll maxl = LLONG_MIN, minl = LLONG_MAX;
int maxi = INT_MIN, mini = INT_MAX;
int n;
cin >> n;
vi h(n);
rv(h);
vector<int> dp(n);
dp[0] = 0;
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]));
cout << dp[n - 1] << endl;
}
int32_t main() {
FAST;
int t = 1;
while (t--) {
solve();
}
}
| [] | 952,227 | 952,228 | u771992664 | cpp |
p03160 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
int dist(int arr[], int n) {
int dp[n + 1], op1, op2;
dp[1] = 0;
for (int i = 2; i <= n; i++) {
op1 = abs(arr[i] - arr[i - 1]) + dp[i - 1];
if (i != 2) {
op2 = abs(arr[i] - arr[i - 2]) + dp[i - 2];
}
dp[i] = min(op1, op2);
}
return dp[n];
}
int main() {
int n;
cin >> n;
int arr[n + 1];
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
cout << dist(arr, n) << endl;
return 0;
} | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
int dist(int arr[], int n) {
int dp[n + 1], op1, op2 = INT_MAX;
dp[1] = 0;
for (int i = 2; i <= n; i++) {
op1 = abs(arr[i] - arr[i - 1]) + dp[i - 1];
if (i != 2) {
op2 = abs(arr[i] - arr[i - 2]) + dp[i - 2];
}
dp[i] = min(op1, op2);
// cout<<dp[i]<<" ";
}
return dp[n];
}
int main() {
int n;
cin >> n;
int arr[n + 1];
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
cout << dist(arr, n) << endl;
return 0;
} | [
"variable_declaration.value.change"
] | 952,231 | 952,232 | u106256464 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++)
cin >> arr[i];
int dp[n] = {};
dp[0] = arr[0];
dp[1] = abs(arr[0] - arr[1]);
for (int i = 2; i < n; i++) {
dp[i] = min(dp[i - 2] + abs(arr[i] - arr[i - 2]),
dp[i - 1] + abs(arr[i] - arr[i - 1]));
}
cout << dp[n - 1] << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
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[0] - arr[1]);
for (int i = 2; i < n; i++) {
dp[i] = min(dp[i - 2] + abs(arr[i] - arr[i - 2]),
dp[i - 1] + abs(arr[i] - arr[i - 1]));
}
cout << dp[n - 1] << endl;
} | [] | 952,245 | 952,246 | u659210268 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int minReach(int arr[], int n) {
int dp[n + 1];
dp[1] = arr[1];
dp[2] = abs(arr[1] - arr[2]);
for (int i = 3; i <= n; i++) {
int ans1 = dp[i - 1] + abs(arr[i] - arr[i - 1]);
int ans2 = dp[i - 2] + abs(arr[i] - arr[i - 2]);
dp[i] = min(ans1, ans2);
}
return dp[n];
}
int main() {
int n;
cin >> n;
int arr[n + 1];
for (int i = 1; i <= n; i++)
cin >> arr[i];
cout << minReach(arr, n) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int minReach(int arr[], int n) {
int dp[n + 1];
dp[1] = 0;
dp[2] = abs(arr[1] - arr[2]);
for (int i = 3; i <= n; i++) {
int ans1 = dp[i - 1] + abs(arr[i] - arr[i - 1]);
int ans2 = dp[i - 2] + abs(arr[i] - arr[i - 2]);
dp[i] = min(ans1, ans2);
}
return dp[n];
}
int main() {
int n;
cin >> n;
int arr[n + 1];
for (int i = 1; i <= n; i++)
cin >> arr[i];
cout << minReach(arr, n) << endl;
return 0;
}
| [
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add"
] | 952,247 | 952,248 | u193875150 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int heights[N];
for (int i = 0; i < N; ++i) {
cin >> heights[i];
}
int a = abs(heights[1] - heights[0]), b = abs(heights[2] - heights[0]),
ans = 0;
for (int i = 1; i < N - 1; ++i) {
if (i % 2 == 1) {
b = min(b, a + abs(heights[i] - heights[i + 1]));
if (i != N - 2) {
a = a + abs(heights[i] - heights[i + 2]);
} else {
ans = b;
}
} else {
a = min(a, b + abs(heights[i] - heights[i + 1]));
if (i != N - 2) {
b = b + abs(heights[i] - heights[i + 2]);
} else {
ans = a;
}
}
}
cout << ans;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int heights[N];
for (int i = 0; i < N; ++i) {
cin >> heights[i];
}
int a = abs(heights[1] - heights[0]), b = abs(heights[2] - heights[0]),
ans = a;
for (int i = 1; i < N - 1; ++i) {
if (i % 2 == 1) {
b = min(b, a + abs(heights[i] - heights[i + 1]));
if (i != N - 2) {
a = a + abs(heights[i] - heights[i + 2]);
} else {
ans = b;
}
} else {
a = min(a, b + abs(heights[i] - heights[i + 1]));
if (i != N - 2) {
b = b + abs(heights[i] - heights[i + 2]);
} else {
ans = a;
}
}
}
cout << ans;
}
| [
"variable_declaration.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 952,251 | 952,252 | u007332755 | cpp |
p03160 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> h;
for (int i = 0; i < n; i++) {
int temp;
cin >> temp;
h.push_back(temp);
}
vector<int> dp(n, 0);
dp[0] = h[0];
dp[1] = abs(dp[0] - h[1]);
for (int i = 2; i < n; i++) {
dp[i] +=
min(abs(h[i] - h[i - 1]) + dp[i - 1], abs(h[i] - h[i - 2]) + dp[i - 2]);
}
cout << dp[n - 1];
} | #include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> h;
for (int i = 0; i < n; i++) {
int temp;
cin >> temp;
h.push_back(temp);
}
vector<int> dp(n, 0);
dp[0] = 0;
dp[1] = abs(h[0] - h[1]);
for (int i = 2; i < n; i++) {
dp[i] +=
min(abs(h[i] - h[i - 1]) + dp[i - 1], abs(h[i] - h[i - 2]) + dp[i - 2]);
}
cout << dp[n - 1];
} | [
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 952,253 | 952,254 | u108976315 | cpp |
p03160 | #include <algorithm>
#include <iostream>
#include <vector>
#define lli long long int
#define INF 1e9 + 5
using namespace std;
int absdiff(int a, int b) {
if (a > b)
return a - b;
else
return b - a;
}
int main() {
int n;
cin >> n;
vector<int> h;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
h.push_back(x);
}
// dp[i] minimum cost to reach this step
vector<int> dp(n, INF);
dp[0] = 0, dp[1] = h[1] - h[0];
for (int i = 2; i < n; i++) {
dp[i] = min(dp[i - 1] + absdiff(h[i], h[i - 1]),
dp[i - 2] + absdiff(h[i], h[i - 2]));
// cout<<i<<dp[i]<<endl;
}
cout << dp[n - 1] << endl;
} | #include <algorithm>
#include <iostream>
#include <vector>
#define lli long long int
#define INF 1e9 + 5
using namespace std;
int absdiff(int a, int b) {
if (a > b)
return a - b;
else
return b - a;
}
int main() {
int n;
cin >> n;
vector<int> h;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
h.push_back(x);
}
// dp[i] minimum cost to reach this step
vector<int> dp(n, INF);
dp[0] = 0, dp[1] = absdiff(h[1], h[0]);
for (int i = 2; i < n; i++) {
dp[i] = min(dp[i - 1] + absdiff(h[i], h[i - 1]),
dp[i - 2] + absdiff(h[i], h[i - 2]));
}
cout << dp[n - 1] << endl;
} | [
"call.add",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 952,255 | 952,256 | u375055372 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
void boost() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
int main() {
boost();
ll n;
cin >> n;
ll arr[n], i;
for (i = 0; i < n; i++)
cin >> arr[i];
ll dp[n + 1];
dp[0] = arr[0];
dp[1] = abs(arr[1] - arr[0]);
if (n == 2) {
cout << arr[0] - arr[1] << endl;
} else {
dp[2] = min(abs(arr[2] - arr[0]), dp[1] + abs(arr[2] - arr[1]));
for (i = 3; i < n; i++)
dp[i] = min(dp[i - 2] + abs(arr[i] - arr[i - 2]),
dp[i - 1] + abs(arr[i] - arr[i - 1]));
}
// for(i=0;i<n;i++)
// cout << dp[i] << " ";
// cout << endl;
cout << dp[n - 1] << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
void boost() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
int main() {
boost();
ll n;
cin >> n;
ll arr[n], i;
for (i = 0; i < n; i++)
cin >> arr[i];
ll dp[n + 1];
dp[0] = arr[0];
dp[1] = abs(arr[1] - arr[0]);
if (n == 2) {
cout << abs(arr[0] - arr[1]) << endl;
} else {
dp[2] = min(abs(arr[2] - arr[0]), dp[1] + abs(arr[2] - arr[1]));
for (i = 3; i < n; i++)
dp[i] = min(dp[i - 2] + abs(arr[i] - arr[i - 2]),
dp[i - 1] + abs(arr[i] - arr[i - 1]));
cout << dp[n - 1] << endl;
}
// for(i=0;i<n;i++)
// cout << dp[i] << " ";
// cout << endl;
} | [
"call.add",
"call.arguments.change"
] | 952,257 | 952,258 | u960935381 | 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[10010];
long long dp[10010];
long long rec(int i) {
if (dp[i] < INF)
return dp[i];
if (i == 0)
return 0;
long long res = INF;
chmin(res, rec(i - 1) + abs(h[i] - h[i - 1]));
if (i > 1)
chmin(res, rec(i - 2) + abs(h[i] - h[i - 2]));
return dp[i] = res;
}
int main() {
int N;
cin >> N;
for (int i = 0; i < N; ++i)
cin >> h[i];
// 初期化 (最小化問題なので INF に初期化)
for (int i = 0; i < 100010; ++i)
dp[i] = INF;
// 答え
cout << rec(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];
long long rec(int i) {
if (dp[i] < INF)
return dp[i];
if (i == 0)
return 0;
long long res = INF;
chmin(res, rec(i - 1) + abs(h[i] - h[i - 1]));
if (i > 1)
chmin(res, rec(i - 2) + abs(h[i] - h[i - 2]));
return dp[i] = res;
}
int main() {
int N;
cin >> N;
for (int i = 0; i < N; ++i)
cin >> h[i];
// 初期化 (最小化問題なので INF に初期化)
for (int i = 0; i < 100010; ++i)
dp[i] = INF;
// 答え
cout << rec(N - 1) << endl;
}
| [
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 952,259 | 952,260 | u993268357 | cpp |
p03160 | #include <cstdlib>
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int h[n + 1];
for (int i = 1; i <= n; i++)
cin >> h[i];
int dp[n + 1];
for (int i = 2; i <= n; i++) {
dp[1] = 1000000;
if (i == 2)
dp[2] = abs(h[2] - h[1]);
else {
dp[i] = min(dp[i - 1] + abs(h[i] - h[i - 1]),
dp[i - 2] + abs(h[i - 2] - h[i]));
}
}
cout << dp[n] << endl;
} | #include <cstdlib>
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int h[n + 1];
for (int i = 1; i <= n; i++)
cin >> h[i];
int dp[n + 1];
for (int i = 2; i <= n; i++) {
dp[1] = 0;
if (i == 2)
dp[2] = abs(h[2] - h[1]);
else {
dp[i] = min(dp[i - 1] + abs(h[i] - h[i - 1]),
dp[i - 2] + abs(h[i - 2] - h[i]));
}
}
cout << dp[n] << endl;
} | [
"literal.number.change",
"assignment.value.change"
] | 952,263 | 952,264 | u032955959 | cpp |
p03160 |
#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int mxN = 1e5, INF = 1e9 + 7;
int n;
vector<int> h(mxN);
vector<int> dp(mxN + 1, INF);
int main() {
cin >> n;
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 << dp[n];
}
|
#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int mxN = 1e5, INF = 1e9 + 7;
int n;
vector<int> h(mxN + 1);
vector<int> dp(mxN + 1);
int main() {
cin >> n;
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 << dp[n];
}
| [
"call.arguments.change"
] | 952,267 | 952,266 | u973157631 | 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];
}
vector<int> dp(n, 0);
// dp[1]=h[1]-h[0];
dp[1] = abs(h[2] - h[1]);
for (int i = 2; i < n; i++) {
dp[i] =
min(abs(h[i] - h[i - 1]) + dp[i - 1], abs(h[i - 2] - h[i]) + dp[i - 2]);
}
cout << dp[n - 1];
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];
}
vector<int> dp(n, 0);
// dp[1]=h[1]-h[0];
dp[1] = abs(h[1] - h[0]);
for (int i = 2; i < n; i++) {
dp[i] =
min(abs(h[i] - h[i - 1]) + dp[i - 1], abs(h[i - 2] - h[i]) + dp[i - 2]);
}
cout << dp[n - 1];
return 0;
} | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 952,271 | 952,272 | u485607024 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 5;
int main() {
int n;
cin >> n;
int h[n];
int i = 0;
int dp[n];
while (i < n) {
cin >> h[i];
dp[i] = INF;
i++;
}
i = 1;
dp[0] = 0;
for (; i < n; i++) {
int j = 1;
while (j < 3) {
if (i + j < n)
dp[i + j] = min(dp[i + j], abs(h[i] - h[i + j]) + dp[i]);
j++;
}
}
cout << dp[n - 1] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 5;
int main() {
int n;
cin >> n;
int h[n];
int i = 0;
int dp[n];
while (i < n) {
cin >> h[i];
dp[i] = INF;
i++;
}
i = 0;
dp[0] = 0;
for (; i < n; i++) {
int j = 1;
while (j < 3) {
if (i + j < n)
dp[i + j] = min(dp[i + j], abs(h[i] - h[i + j]) + dp[i]);
j++;
}
// cout<<dp[i]<<" ";
}
cout << dp[n - 1] << endl;
return 0;
} | [
"literal.number.change",
"assignment.value.change"
] | 952,277 | 952,278 | u931624197 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define pb push_back
#define sz(x) (int)(x).size()
#define all(x) (x).begin(), (x).end()
#define trav(a, x) for (auto &a : x)
const int INF = 1e5;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n;
cin >> n;
vector<ll> h(n);
for (int i = 0; i < n; ++i)
cin >> h[i];
vector<ll> dp(n, INF);
dp[0] = 0;
for (int i = 1; i < n; ++i) {
for (int j = 1; j <= 2; ++j) {
if (i >= j)
dp[i] = min(dp[i], dp[i - j] + abs(h[i] - h[i - j]));
}
}
cout << dp[n - 1] << '\n';
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define pb push_back
#define sz(x) (int)(x).size()
#define all(x) (x).begin(), (x).end()
#define trav(a, x) for (auto &a : x)
const ll INF = 1e18;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n;
cin >> n;
vector<ll> h(n);
for (int i = 0; i < n; ++i)
cin >> h[i];
vector<ll> dp(n, INF);
dp[0] = 0;
for (int i = 1; i < n; ++i) {
for (int j = 1; j <= 2; ++j) {
if (i >= j)
dp[i] = min(dp[i], dp[i - j] + abs(h[i] - h[i - j]));
}
}
cout << dp[n - 1] << '\n';
return 0;
}
| [
"variable_declaration.type.change",
"literal.number.change",
"variable_declaration.value.change"
] | 952,279 | 952,280 | u195278459 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define pb push_back
#define sz(x) (int)(x).size()
#define all(x) (x).begin(), (x).end()
#define trav(a, x) for (auto &a : x)
const int INF = 1e5;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n;
cin >> n;
vector<int> h(n);
for (int i = 0; i < n; ++i)
cin >> h[i];
vector<int> dp(n, INF);
dp[0] = 0;
for (int i = 1; i < n; ++i) {
for (int j = 1; j <= 2; ++j) {
if (i >= j)
dp[i] = min(dp[i], dp[i - j] + abs(h[i] - h[i - j]));
}
}
cout << dp[n - 1] << '\n';
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define pb push_back
#define sz(x) (int)(x).size()
#define all(x) (x).begin(), (x).end()
#define trav(a, x) for (auto &a : x)
const ll INF = 1e18;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n;
cin >> n;
vector<ll> h(n);
for (int i = 0; i < n; ++i)
cin >> h[i];
vector<ll> dp(n, INF);
dp[0] = 0;
for (int i = 1; i < n; ++i) {
for (int j = 1; j <= 2; ++j) {
if (i >= j)
dp[i] = min(dp[i], dp[i - j] + abs(h[i] - h[i - j]));
}
}
cout << dp[n - 1] << '\n';
return 0;
}
| [
"variable_declaration.type.change",
"literal.number.change",
"variable_declaration.value.change"
] | 952,281 | 952,280 | u195278459 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define endl "\n"
#define int long long
const int N = 1e5 + 5;
const int INF = 1e5 + 5;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
// dp[i] = min value to reach stone n
int h[n];
for (int i = 0; i < n; i++)
cin >> h[i];
vector<int> dp(n, INF);
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j : {i + 1, i + 2}) {
dp[j] = min(dp[j], dp[i] + abs(h[j] - h[i]));
}
}
cout << dp[n - 1] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define endl "\n"
#define int long long
const int N = 1e5 + 5;
const int INF = 1e9 + 5;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
// dp[i] = min value to reach stone n
int h[n];
for (int i = 0; i < n; i++)
cin >> h[i];
vector<int> dp(n, INF);
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j : {i + 1, i + 2}) {
dp[j] = min(dp[j], dp[i] + abs(h[j] - h[i]));
}
}
cout << dp[n - 1] << endl;
return 0;
} | [
"literal.number.change",
"expression.operation.binary.change"
] | 952,282 | 952,283 | u669936199 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define fi first
#define se second
#define sz(x) ((int)(x).size())
#define zeroend __builtin_ctz
#define ones __builtin_popcount
#define ends "\n"
#define space ' '
typedef long long ll;
typedef pair<int, int> pii;
/*
void solve(int i, int j, string s){
if(i==0)
ans.insert(s2.substr(0, j)+s);
else if(j==0)
ans.insert(s1.substr(0, i)+s);
else if(s1[i-1]==s2[j-1])
solve(i-1, j-1, s1[i-1]+s);
else{
if(dp[i-1][j]<=dp[i][j-1])
solve(i-1, j, s1[i-1]+s);
if(dp[i-1][j]>=dp[i][j-1])
solve(i, j-1, s2[j-1]+s);
}
}*/
/*
cin >> n;
for(int i=0; i<n; ++i)
cin >> a[i];
for(int i=1; i<n; ++i){
for(int j=0; j<i; ++j){
if(a[j]>a[i]&&low[i]<high[j]+1)
low[i]=high[j]+1;
else if(a[j]<a[i]&&high[i]<low[j]+1)
high[i]=low[j]+1;
}
ans=max({ans, low[i], high[i]});
}
cout << ans << ends;
*/
const int N = 1e5, M = 1e9 + 7;
ll dp[N];
// set<string> ans;
// vector<int> low(N, 1), high(N, 1);
ll a[N];
int n;
int main() {
cin >> n;
for (int i = 0; i < n; ++i)
cin >> a[i];
dp[0] = a[0];
dp[1] = abs(a[1] - a[0]);
for (int i = 2; i < n; ++i)
dp[i] =
min(abs(a[i] - a[i - 1]) + dp[i - 1], abs(a[i] - a[i - 2]) + dp[i - 2]);
cout << dp[n - 1] << ends;
}
| #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define fi first
#define se second
#define sz(x) ((int)(x).size())
#define zeroend __builtin_ctz
#define ones __builtin_popcount
#define ends "\n"
#define space ' '
typedef long long ll;
typedef pair<int, int> pii;
/*
void solve(int i, int j, string s){
if(i==0)
ans.insert(s2.substr(0, j)+s);
else if(j==0)
ans.insert(s1.substr(0, i)+s);
else if(s1[i-1]==s2[j-1])
solve(i-1, j-1, s1[i-1]+s);
else{
if(dp[i-1][j]<=dp[i][j-1])
solve(i-1, j, s1[i-1]+s);
if(dp[i-1][j]>=dp[i][j-1])
solve(i, j-1, s2[j-1]+s);
}
}*/
/*
cin >> n;
for(int i=0; i<n; ++i)
cin >> a[i];
for(int i=1; i<n; ++i){
for(int j=0; j<i; ++j){
if(a[j]>a[i]&&low[i]<high[j]+1)
low[i]=high[j]+1;
else if(a[j]<a[i]&&high[i]<low[j]+1)
high[i]=low[j]+1;
}
ans=max({ans, low[i], high[i]});
}
cout << ans << ends;
*/
const int N = 1e5, M = 1e9 + 7;
ll dp[N];
// set<string> ans;
// vector<int> low(N, 1), high(N, 1);
ll a[N];
int n;
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(abs(a[i] - a[i - 1]) + dp[i - 1], abs(a[i] - a[i - 2]) + dp[i - 2]);
cout << dp[n - 1] << ends;
}
| [] | 952,286 | 952,287 | u130030265 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define ff first
#define ss second
#define int long long
#define pb push_back
#define mp make_pair
#define pii pair<int, int>
#define vi vector<int>
#define mii map<int, int>
#define pqb priority_queue<int>
#define pqs priority_queue<int, vi, greater<int>>
#define setbits(x) __builtin_popcountll(x)
#define zrobits(x) __builtin_ctzll(x)
#define mod 1000000007
#define inf 1e18
#define ps(x, y) fixed << setprecision(y) << x
#define mk(arr, n, type) type *arr = new type[n];
#define w(x) \
int x; \
cin >> x; \
while (x--)
#define FIO \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int pow(int x, int n) {
int res = 1;
while (n) {
if (n & 1)
res = (res * x);
x = (x * x);
n >>= 1;
}
return res;
}
int solve(int n, int a[]) {
int dp[n + 1] = {};
// dp[0] =0;
int op1 = 0, op2 = 0;
for (int i = 2; i <= n; i++) {
op1 = op2 = INT_MAX;
op1 = abs(a[i] - a[i - 1]) + dp[i - 1];
if (i >= 2)
op2 = abs(a[i] - a[i - 2]) + dp[i - 2];
dp[i] = min(op1, op2);
}
return dp[n];
}
int32_t main() {
// Paawan Singal
FIO;
int n;
cin >> n;
mk(a, n + 1, int);
for (int i = 1; i <= n; i++)
cin >> a[i];
cout << solve(n, a) << '\n';
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ff first
#define ss second
#define int long long
#define pb push_back
#define mp make_pair
#define pii pair<int, int>
#define vi vector<int>
#define mii map<int, int>
#define pqb priority_queue<int>
#define pqs priority_queue<int, vi, greater<int>>
#define setbits(x) __builtin_popcountll(x)
#define zrobits(x) __builtin_ctzll(x)
#define mod 1000000007
#define inf 1e18
#define ps(x, y) fixed << setprecision(y) << x
#define mk(arr, n, type) type *arr = new type[n];
#define w(x) \
int x; \
cin >> x; \
while (x--)
#define FIO \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int pow(int x, int n) {
int res = 1;
while (n) {
if (n & 1)
res = (res * x);
x = (x * x);
n >>= 1;
}
return res;
}
int solve(int n, int a[]) {
int dp[n + 1] = {};
// dp[0] =0;
int op1 = 0, op2 = 0;
for (int i = 2; i <= n; i++) {
op1 = op2 = INT_MAX;
op1 = abs(a[i] - a[i - 1]) + dp[i - 1];
if (i > 2)
op2 = abs(a[i] - a[i - 2]) + dp[i - 2];
dp[i] = min(op1, op2);
}
return dp[n];
}
int32_t main() {
// Paawan Singal
FIO;
int n;
cin >> n;
mk(a, n + 1, int);
for (int i = 1; i <= n; i++)
cin >> a[i];
cout << solve(n, a) << '\n';
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 952,290 | 952,291 | u476737806 | cpp |
p03160 | //#pragma GCC optimize "trapv"
#include <bits/stdc++.h>
#define all(v) v.begin(), v.end()
#define sz(x) (int)x.size()
#define debug(x) cout << '>' << #x << ':' << x << endl;
#define rep(i, n) for (int i = 0; i < n; i++)
#define reps(i, n) for (int i = 1; i <= n; i++)
#define make_unique(v) \
sort(all(v)); \
v.erase(unique(all(v)), v.end());
#define rot(v) rotate(v.begin(), v.begin() + k, v.end());
#define rmv(v, a) v.erase(remove(v.begin(), v.end(), a), v.end());
#define max(x, y) ((x > y) ? x : y)
#define min(x, y) ((x < y) ? x : y)
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define endl '\n'
#define fi first
#define se second
#define ajs(a) (a < 0) ? (-1 * a) : a
using namespace std;
typedef long long ll;
// use count() instead of find() in sets.
const ll MOD = 1e9 + 7;
const double PI = acos(-1.0);
const double EPS = (1e-10);
const int dx4[4] = {0, 1, 0, -1};
const int dy4[4] = {-1, 0, 1, 0};
const int dx8[8] = {-1, -1, -1, 0, 1, 1, 1, 0};
const int dy8[8] = {-1, 0, 1, 1, 1, 0, -1, -1};
bool cmp(int X, int Y) { return X > Y; }
int dcp(double A, double B) { return fabs(A - B) <= EPS ? 0 : A < B ? -1 : 1; }
ll gcd(ll a, ll b) { return !b ? a : gcd(b, a % b); }
ll lcm(ll a, ll b) { return (a / gcd(a, b)) * b; }
ll modpow(ll a, ll b, ll m) {
a %= m;
ll res = 1;
while (b) {
if (b & 1)
res = (res * a) % m;
a = (a * a) % m;
b >>= 1;
}
return res;
}
ll bpow(ll a, ll b) {
ll res = 1;
while (b) {
if (b & 1)
res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
ll modinv(ll a, ll m = MOD) { return modpow(a, m - 2, m); }
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll n;
cin >> n;
ll h[n + 1];
h[0] = 0;
reps(i, n) { cin >> h[i]; }
ll dp[n + 1];
dp[0] = 0;
dp[1] = 0;
dp[2] = h[2] - h[1];
for (ll i = 3; i <= n; i++) {
dp[i] =
min(dp[i - 1] + abs(h[i] - h[i - 1]), dp[i - 2] + abs(h[i] - h[i - 2]));
}
cout << dp[n];
}
| //#pragma GCC optimize "trapv"
#include <bits/stdc++.h>
#define all(v) v.begin(), v.end()
#define sz(x) (int)x.size()
#define debug(x) cout << '>' << #x << ':' << x << endl;
#define rep(i, n) for (int i = 0; i < n; i++)
#define reps(i, n) for (int i = 1; i <= n; i++)
#define make_unique(v) \
sort(all(v)); \
v.erase(unique(all(v)), v.end());
#define rot(v) rotate(v.begin(), v.begin() + k, v.end());
#define rmv(v, a) v.erase(remove(v.begin(), v.end(), a), v.end());
#define max(x, y) ((x > y) ? x : y)
#define min(x, y) ((x < y) ? x : y)
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define endl '\n'
#define fi first
#define se second
#define ajs(a) (a < 0) ? (-1 * a) : a
using namespace std;
typedef long long ll;
// use count() instead of find() in sets.
const ll MOD = 1e9 + 7;
const double PI = acos(-1.0);
const double EPS = (1e-10);
const int dx4[4] = {0, 1, 0, -1};
const int dy4[4] = {-1, 0, 1, 0};
const int dx8[8] = {-1, -1, -1, 0, 1, 1, 1, 0};
const int dy8[8] = {-1, 0, 1, 1, 1, 0, -1, -1};
bool cmp(int X, int Y) { return X > Y; }
int dcp(double A, double B) { return fabs(A - B) <= EPS ? 0 : A < B ? -1 : 1; }
ll gcd(ll a, ll b) { return !b ? a : gcd(b, a % b); }
ll lcm(ll a, ll b) { return (a / gcd(a, b)) * b; }
ll modpow(ll a, ll b, ll m) {
a %= m;
ll res = 1;
while (b) {
if (b & 1)
res = (res * a) % m;
a = (a * a) % m;
b >>= 1;
}
return res;
}
ll bpow(ll a, ll b) {
ll res = 1;
while (b) {
if (b & 1)
res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
ll modinv(ll a, ll m = MOD) { return modpow(a, m - 2, m); }
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll n;
cin >> n;
ll h[n + 1];
h[0] = 0;
reps(i, n) { cin >> h[i]; }
ll dp[n + 1];
dp[0] = 0;
dp[1] = 0;
dp[2] = abs(h[2] - h[1]);
for (ll i = 3; i <= n; i++) {
dp[i] =
min(dp[i - 1] + abs(h[i] - h[i - 1]), dp[i - 2] + abs(h[i] - h[i - 2]));
}
cout << dp[n];
}
| [
"call.add",
"call.arguments.change"
] | 952,292 | 952,293 | u887982593 | 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];
for (int i = 0; i < n; i++) {
dp[i] = 0;
}
dp[0] = 0;
dp[1] = (arr[1] - arr[0]);
for (int i = 2; i < n; i++) {
dp[i] += min(dp[i - 1] + abs(arr[i] - arr[i - 1]),
dp[i - 2] + abs(arr[i] - arr[i - 2]));
}
cout << dp[n - 1];
return 0;
}
| #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];
for (int i = 0; i < n; i++) {
dp[i] = 0;
}
dp[0] = 0;
dp[1] = abs(arr[1] - arr[0]);
for (int i = 2; i < n; i++) {
dp[i] += min(dp[i - 1] + abs(arr[i] - arr[i - 1]),
dp[i - 2] + abs(arr[i] - arr[i - 2]));
}
cout << dp[n - 1];
return 0;
}
| [
"call.add"
] | 952,294 | 952,295 | u724031512 | cpp |
p03160 | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
#define ll long long
#define ld long double
#define pq priority_queue
#define ff first
#define ss second
#define pb push_back
#define pb push_back
#define all(c) (c).begin(), (c).end()
#define ordered_set \
tree<int, null_type, less<int>, rb_tree_tag, \
tree_order_statistics_node_update>
#define MOD1 998244353
#define MOD2 1000000007
typedef pair<ll, ll> ii;
typedef vector<ll> vi;
typedef vector<vi> vvi;
typedef vector<ii> vii;
typedef vector<vii> vvii;
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int h[n];
for (int i = 0; i < n; i++) {
cin >> h[i];
}
int dp[n];
dp[0] = h[0];
dp[1] = abs(h[0] - h[1]);
dp[2] = min(abs(h[0] - h[2]), abs(h[1] - h[2]));
for (int i = 3; i < n; i++) {
dp[i] =
min(abs(h[i] - h[i - 1]) + dp[i - 1], abs(h[i] - h[i - 2]) + dp[i - 2]);
}
cout << dp[n - 1] << endl;
}
| #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
#define ll long long
#define ld long double
#define pq priority_queue
#define ff first
#define ss second
#define pb push_back
#define pb push_back
#define all(c) (c).begin(), (c).end()
#define ordered_set \
tree<int, null_type, less<int>, rb_tree_tag, \
tree_order_statistics_node_update>
#define MOD1 998244353
#define MOD2 1000000007
typedef pair<ll, ll> ii;
typedef vector<ll> vi;
typedef vector<vi> vvi;
typedef vector<ii> vii;
typedef vector<vii> vvii;
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int h[n];
for (int i = 0; i < n; i++) {
cin >> h[i];
}
int dp[n];
dp[0] = h[0];
dp[1] = abs(h[0] - h[1]);
dp[2] = min(abs(h[0] - h[2]), abs(h[1] - h[2]) + dp[1]);
for (int i = 3; i < n; i++) {
dp[i] =
min(abs(h[i] - h[i - 1]) + dp[i - 1], abs(h[i] - h[i - 2]) + dp[i - 2]);
}
cout << dp[n - 1] << endl;
}
| [
"assignment.change"
] | 952,298 | 952,299 | u965116893 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define mod 1000000009
#define ll long long
#define mp make_pair
#define pb push_back
#define ff first
#define ss second
#define set0(a) memset((a), 0, sizeof(a))
#define set1(a) memset((a), -1, sizeof(a))
#define pi pair<int, int>
#define ps pair<string, string>
#define pl pair<long, long>
#define pll pair<long long, long long>
#define vll vector<long long>
#define vl vector<long>
#define vi vector<int>
#define vs vector<string>
#define vps vector<ps>
#define vpi vector<pi>
#define vpl vector<pl>
#define vpll vector<pll>
#define flash \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
#define tc(t, T) for (long long t = 0; t < T; t++)
#define rep(i, s, n, d) for (long long i = s; i < n; i = i + d)
#define meax 100007
vll a(meax, 0);
vll b(meax, meax);
ll sum1 = 0;
ll maximize(ll i, ll n, ll prev) {
if (b[i] != meax) {
return b[i];
}
if (i >= n) {
return meax;
}
if (i == n - 1) {
b[i] = 0;
return b[i];
}
ll d1 = maximize(i + 1, n, a[i]);
ll d2 = maximize(i + 2, n, a[i]);
b[i] = min(abs(a[i] - a[i + 1]) + d1, abs(a[i + 2] - a[i]) + d2);
}
int main() {
ll n;
cin >> n;
rep(i, 0, n, 1) { cin >> a[i]; }
ll d = maximize(0, n, a[0]);
cout << d << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define mod 1000000009
#define ll long long
#define mp make_pair
#define pb push_back
#define ff first
#define ss second
#define set0(a) memset((a), 0, sizeof(a))
#define set1(a) memset((a), -1, sizeof(a))
#define pi pair<int, int>
#define ps pair<string, string>
#define pl pair<long, long>
#define pll pair<long long, long long>
#define vll vector<long long>
#define vl vector<long>
#define vi vector<int>
#define vs vector<string>
#define vps vector<ps>
#define vpi vector<pi>
#define vpl vector<pl>
#define vpll vector<pll>
#define flash \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
#define tc(t, T) for (long long t = 0; t < T; t++)
#define rep(i, s, n, d) for (long long i = s; i < n; i = i + d)
#define meax 100007
vll a(meax, 0);
vll b(meax, meax);
ll sum1 = 0;
ll maximize(ll i, ll n, ll prev) {
if (b[i] != meax) {
return b[i];
}
if (i >= n) {
return meax;
}
if (i == n - 1) {
b[i] = 0;
return b[i];
}
ll d1 = maximize(i + 1, n, a[i]);
ll d2 = maximize(i + 2, n, a[i]);
b[i] = min(abs(a[i] - a[i + 1]) + d1, abs(a[i + 2] - a[i]) + d2);
return b[i];
}
int main() {
ll n;
cin >> n;
rep(i, 0, n, 1) { cin >> a[i]; }
ll d = maximize(0, n, a[0]);
cout << d << endl;
}
| [
"control_flow.return.add"
] | 952,300 | 952,301 | u544149677 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define mod 1000000007
#define fast() \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
void solve() {
ll n;
cin >> n;
ll arr[n], i;
for (i = 0; i < n; i++) {
cin >> arr[i];
}
ll ans = 0;
ll dp[n];
dp[0] = 0;
dp[1] = abs(arr[1] - arr[0]);
for (i = 2; i < n; i++) {
dp[i] = min(dp[i - 1] + abs(arr[i] - arr[i - 1]),
dp[i - 1] + abs(arr[i] - arr[i - 2]));
}
cout << dp[n - 1];
}
int main() {
fast();
solve();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define mod 1000000007
#define fast() \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
void solve() {
ll n;
cin >> n;
ll arr[n], i;
for (i = 0; i < n; i++) {
cin >> arr[i];
}
ll ans = 0;
ll dp[n];
dp[0] = 0;
dp[1] = abs(arr[1] - arr[0]);
for (i = 2; i < n; i++) {
dp[i] = min(dp[i - 1] + abs(arr[i] - arr[i - 1]),
dp[i - 2] + abs(arr[i] - arr[i - 2]));
}
cout << dp[n - 1];
}
int main() {
fast();
solve();
return 0;
}
| [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 952,317 | 952,318 | u290308915 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> h(N + 1);
h.at(0) = 100000;
for (int i = 1; i <= N; i++) {
cin >> h.at(i);
}
vector<int64_t> cost(N + 1, 100000);
cost.at(0) = 0;
cost.at(1) = 0;
for (int i = 2; i <= N; i++) {
cost.at(i) = min((cost.at(i - 1) + abs(h.at(i - 1) - h.at(i))), cost.at(i));
cost.at(i) = min(cost.at(i), (cost.at(i - 2) + abs(h.at(i - 2) - h.at(i))));
}
cout << cost.at(N) << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> h(N + 1);
h.at(0) = 100000;
for (int i = 1; i <= N; i++) {
cin >> h.at(i);
}
vector<int64_t> cost(N + 1, 1000000000000000);
cost.at(0) = 0;
cost.at(1) = 0;
for (int i = 2; i <= N; i++) {
cost.at(i) = min((cost.at(i - 1) + abs(h.at(i - 1) - h.at(i))), cost.at(i));
cost.at(i) = min(cost.at(i), (cost.at(i - 2) + abs(h.at(i - 2) - h.at(i))));
}
cout << cost.at(N) << endl;
}
| [
"literal.number.change",
"call.arguments.change"
] | 952,319 | 952,320 | u453366189 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> h(N + 1);
h.at(0) = 100000;
for (int i = 1; i <= N; i++) {
cin >> h.at(i);
}
vector<int> cost(N + 1, 100000);
cost.at(0) = 0;
cost.at(1) = 0;
for (int i = 2; i <= N; i++) {
cost.at(i) = min((cost.at(i - 1) + abs(h.at(i - 1) - h.at(i))), cost.at(i));
cost.at(i) = min(cost.at(i), (cost.at(i - 2) + abs(h.at(i - 2) - h.at(i))));
}
cout << cost.at(N) << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> h(N + 1);
h.at(0) = 100000;
for (int i = 1; i <= N; i++) {
cin >> h.at(i);
}
vector<int64_t> cost(N + 1, 1000000000000000);
cost.at(0) = 0;
cost.at(1) = 0;
for (int i = 2; i <= N; i++) {
cost.at(i) = min((cost.at(i - 1) + abs(h.at(i - 1) - h.at(i))), cost.at(i));
cost.at(i) = min(cost.at(i), (cost.at(i - 2) + abs(h.at(i - 2) - h.at(i))));
}
cout << cost.at(N) << endl;
}
| [
"variable_declaration.type.primitive.change",
"literal.number.change",
"call.arguments.change"
] | 952,321 | 952,320 | u453366189 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> h(N + 1);
h.at(0) = 100000;
for (int i = 1; i <= N; i++) {
cin >> h.at(i);
}
vector<int> cost(N + 1, 100000);
cost.at(0) = 0;
cost.at(1) = 0;
for (int i = 2; i <= N; i++) {
cost.at(i) = min((cost.at(i - 1) + abs(h.at(i - 1) - h.at(i))), cost.at(i));
cost.at(i) =
min(cost.at(i), (cost.at(i - 2) + abs(h.at(i - 2) - h.at(i - 1))));
}
cout << cost.at(N) << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> h(N + 1);
h.at(0) = 100000;
for (int i = 1; i <= N; i++) {
cin >> h.at(i);
}
vector<int64_t> cost(N + 1, 1000000000000000);
cost.at(0) = 0;
cost.at(1) = 0;
for (int i = 2; i <= N; i++) {
cost.at(i) = min((cost.at(i - 1) + abs(h.at(i - 1) - h.at(i))), cost.at(i));
cost.at(i) = min(cost.at(i), (cost.at(i - 2) + abs(h.at(i - 2) - h.at(i))));
}
cout << cost.at(N) << endl;
}
| [
"variable_declaration.type.primitive.change",
"literal.number.change",
"call.arguments.change"
] | 952,322 | 952,320 | u453366189 | cpp |
p03160 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int n, k;
cin >> n;
int A[n];
for (int i = 0; i < n; i++) {
cin >> A[i];
}
int dp[n];
dp[0] = 0;
dp[1] = A[1] - A[0];
for (int i = 2; i < n; i++) {
dp[i] =
min(dp[i - 2] + abs(A[i] - A[i - 2]), dp[i - 1] + abs(A[i] - A[i - 1]));
}
cout << dp[n - 1];
}
| #include <iostream>
#include <vector>
using namespace std;
int main() {
int n, k;
cin >> n;
int A[n];
for (int i = 0; i < n; i++) {
cin >> A[i];
}
int dp[n];
dp[0] = 0;
dp[1] = abs(A[1] - A[0]);
for (int i = 2; i < n; i++) {
dp[i] =
min(dp[i - 2] + abs(A[i] - A[i - 2]), dp[i - 1] + abs(A[i] - A[i - 1]));
}
cout << dp[n - 1];
}
| [
"call.add",
"call.arguments.change"
] | 952,323 | 952,324 | u558926332 | cpp |
p03160 | #include <bits/stdc++.h>
#define endl "\n"
#define ll long long int
#define vi vector<int>
#define vll vector<ll>
#define vvi vector<vi>
#define pii pair<int, int>
#define pll pair<long long, long long>
#define mod 1000000007
#define inf 1000000000000000001;
#define all(c) c.begin(), c.end()
#define mp(x, y) make_pair(x, y)
#define mem(a, val) memset(a, val, sizeof(a))
#define pb push_back
#define f first
#define se second
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
ll n = 0, m = 0, k = 0, x = 0, t1 = 0, t2 = 0, t3 = 0, f = 0, sum = 0,
count = 0;
cin >> n;
ll arr[n + 1], dp[n + 1];
arr[0] = dp[0] = 0;
for (ll i = 1; i <= n; ++i) {
cin >> arr[i];
}
dp[1] = 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] << endl;
return 0;
} | #include <bits/stdc++.h>
#define endl "\n"
#define ll long long int
#define vi vector<int>
#define vll vector<ll>
#define vvi vector<vi>
#define pii pair<int, int>
#define pll pair<long long, long long>
#define mod 1000000007
#define inf 1000000000000000001;
#define all(c) c.begin(), c.end()
#define mp(x, y) make_pair(x, y)
#define mem(a, val) memset(a, val, sizeof(a))
#define pb push_back
#define f first
#define se second
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
ll n = 0, m = 0, k = 0, x = 0, t1 = 0, t2 = 0, t3 = 0, f = 0, sum = 0,
count = 0;
cin >> n;
ll arr[n + 1], dp[n + 1];
arr[0] = inf;
dp[0] = inf;
for (ll i = 1; i <= n; ++i) {
cin >> arr[i];
}
dp[1] = 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] << endl;
return 0;
} | [
"assignment.add",
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 952,325 | 952,326 | u344194703 | cpp |
p03160 | #include <bits/stdc++.h>
#define endl "\n"
#define ll long long int
#define vi vector<int>
#define vll vector<ll>
#define vvi vector<vi>
#define pii pair<int, int>
#define pll pair<long long, long long>
#define mod 1000000007
#define inf 1000000000000000001;
#define all(c) c.begin(), c.end()
#define mp(x, y) make_pair(x, y)
#define mem(a, val) memset(a, val, sizeof(a))
#define pb push_back
#define f first
#define se second
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
ll n = 0, m = 0, k = 0, x = 0, t1 = 0, t2 = 0, t3 = 0, f = 0, sum = 0,
count = 0;
cin >> n;
ll arr[n + 1], dp[n + 1];
arr[0] = dp[0] = 0;
for (ll i = 1; i <= n; ++i) {
cin >> arr[i];
}
dp[1] = 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] << endl;
return 0;
} | #include <bits/stdc++.h>
#define endl "\n"
#define ll long long int
#define vi vector<int>
#define vll vector<ll>
#define vvi vector<vi>
#define pii pair<int, int>
#define pll pair<long long, long long>
#define mod 1000000007
#define inf 1000000000000000001;
#define all(c) c.begin(), c.end()
#define mp(x, y) make_pair(x, y)
#define mem(a, val) memset(a, val, sizeof(a))
#define pb push_back
#define f first
#define se second
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
ll n = 0, m = 0, k = 0, x = 0, t1 = 0, t2 = 0, t3 = 0, f = 0, sum = 0,
count = 0;
cin >> n;
ll arr[n + 1], dp[n + 1];
arr[0] = 0;
dp[0] = inf;
for (ll i = 1; i <= n; ++i) {
cin >> arr[i];
}
dp[1] = 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] << endl;
return 0;
} | [
"assignment.change",
"assignment.add"
] | 952,325 | 952,327 | u344194703 | cpp |
p03160 | #include <bits/stdc++.h>
#define endl "\n"
#define ll long long int
#define vi vector<int>
#define vll vector<ll>
#define vvi vector<vi>
#define pii pair<int, int>
#define pll pair<long long, long long>
#define mod 1000000007
#define inf 1000000000000000001;
#define all(c) c.begin(), c.end()
#define mp(x, y) make_pair(x, y)
#define mem(a, val) memset(a, val, sizeof(a))
#define pb push_back
#define f first
#define se second
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
ll n = 0, m = 0, k = 0, x = 0, t1 = 0, t2 = 0, t3 = 0, f = 0, sum = 0,
count = 0;
cin >> n;
ll arr[n + 1], dp[n + 1];
arr[0] = dp[0] = 0;
for (ll i = 1; i <= n; ++i) {
cin >> arr[i];
}
dp[1] = 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] << endl;
return 0;
} | #include <bits/stdc++.h>
#define endl "\n"
#define ll long long int
#define vi vector<int>
#define vll vector<ll>
#define vvi vector<vi>
#define pii pair<int, int>
#define pll pair<long long, long long>
#define mod 1000000007
#define inf 1000000000000000001;
#define all(c) c.begin(), c.end()
#define mp(x, y) make_pair(x, y)
#define mem(a, val) memset(a, val, sizeof(a))
#define pb push_back
#define f first
#define se second
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
ll n = 0, m = 0, k = 0, x = 0, t1 = 0, t2 = 0, t3 = 0, f = 0, sum = 0,
count = 0;
cin >> n;
ll arr[n + 1], dp[n + 1];
arr[0] = inf;
dp[0] = 0;
for (ll i = 1; i <= n; ++i) {
cin >> arr[i];
}
dp[1] = 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] << endl;
return 0;
} | [
"assignment.add"
] | 952,325 | 952,328 | u344194703 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define pii pair<ll, ll>
#define SZ(x) ((int)(x).size())
#define endl "\n"
ll mod = 1e9 + 7;
// const double pi = acos(-1.0);
/*
ll kmp(string x)
{
ll n= x.length();
//cout<<x<<endl;
vector<ll> lcp(x.length(), 0);
for(ll i=1;i<n;i++)
{
ll j=lcp[i-1];
while(j>0 && x[j]!=x[i])
j=lcp[j-1];
if(x[i]==x[j])
j++;
lcp[i]=j;
}
return lcp[n-1];
}
int N = 1000002;
int ar[100002];
void sieve()
{
for(int i=1;i<=N;i++)
ar[i] = 1;
ar[0] = 0;
for(int i=2;i*i<=N;i++)
{
if(ar[i] && i*i<=N)
{
for(int j = i*i; j<=N;j+=i)
ar[j] = 0;
}
}
}
ll modex(ll a,ll b){
if(b<=0){
return 1;
}
if(b%2==0)
{
ll x = modex(a, b/2);
return ((x*x)%mod);
}
else
return ((a%mod * modex(a, b-1))%mod);
}
ll c[1010][1010];
ll combina(ll i, ll j){
for (int i=0;i<=1005;i++)
for (int j=0;j<=i;j++)
{
if (j==i||j==0)
c[i][j]=1;
else
c[i][j]=c[i-1][j-1]+c[i-1][j];
c[i][j]%=mod;
}
return c[i][j];
}
void find_fac(int x){
vector<ll> di;
for(ll i = 2; i*i <= x; i++)
{
if(x%i==0){
di.push_back(i);
while(x%i==0)
x/=i;
}
}
if(x > 1)
di.push_back(x);
}
*/
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout << fixed;
cout.precision(12);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
vector<int> dp(n);
dp[0] = a[0];
dp[1] = abs(a[1] - a[0]);
for (int i = 2; i < n; i++) {
dp[i] =
min(dp[i - 1] + abs(a[i] - a[i - 1]), dp[i - 2] + abs(a[i] - a[i - 2]));
}
cout << dp[n - 1] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define pii pair<ll, ll>
#define SZ(x) ((int)(x).size())
#define endl "\n"
ll mod = 1e9 + 7;
// const double pi = acos(-1.0);
/*
ll kmp(string x)
{
ll n= x.length();
//cout<<x<<endl;
vector<ll> lcp(x.length(), 0);
for(ll i=1;i<n;i++)
{
ll j=lcp[i-1];
while(j>0 && x[j]!=x[i])
j=lcp[j-1];
if(x[i]==x[j])
j++;
lcp[i]=j;
}
return lcp[n-1];
}
int N = 1000002;
int ar[100002];
void sieve()
{
for(int i=1;i<=N;i++)
ar[i] = 1;
ar[0] = 0;
for(int i=2;i*i<=N;i++)
{
if(ar[i] && i*i<=N)
{
for(int j = i*i; j<=N;j+=i)
ar[j] = 0;
}
}
}
ll modex(ll a,ll b){
if(b<=0){
return 1;
}
if(b%2==0)
{
ll x = modex(a, b/2);
return ((x*x)%mod);
}
else
return ((a%mod * modex(a, b-1))%mod);
}
ll c[1010][1010];
ll combina(ll i, ll j){
for (int i=0;i<=1005;i++)
for (int j=0;j<=i;j++)
{
if (j==i||j==0)
c[i][j]=1;
else
c[i][j]=c[i-1][j-1]+c[i-1][j];
c[i][j]%=mod;
}
return c[i][j];
}
void find_fac(int x){
vector<ll> di;
for(ll i = 2; i*i <= x; i++)
{
if(x%i==0){
di.push_back(i);
while(x%i==0)
x/=i;
}
}
if(x > 1)
di.push_back(x);
}
*/
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout << fixed;
cout.precision(12);
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] =
min(dp[i - 1] + abs(a[i] - a[i - 1]), dp[i - 2] + abs(a[i] - a[i - 2]));
}
cout << dp[n - 1] << endl;
return 0;
}
| [] | 952,329 | 952,330 | u554953113 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
std::vector<int> arr(n);
std::vector<int> dp(n);
for (int i = 0; i < n; ++i)
cin >> arr[i];
dp[0] = 0;
dp[1] = arr[1] - arr[0];
for (int i = 2; i < n; ++i) {
dp[i] = min(dp[i - 1] + abs(arr[i] - arr[i - 1]),
dp[i - 2] + abs(arr[i] - arr[i - 2]));
}
cout << dp[n - 1];
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
std::vector<int> arr(n);
std::vector<int> dp(n);
for (int i = 0; i < n; ++i)
cin >> arr[i];
dp[0] = 0;
dp[1] = abs(arr[1] - arr[0]);
for (int i = 2; i < n; ++i) {
dp[i] = min(dp[i - 1] + abs(arr[i] - arr[i - 1]),
dp[i - 2] + abs(arr[i] - arr[i - 2]));
}
cout << dp[n - 1];
return 0;
}
| [
"call.add",
"call.arguments.change"
] | 952,331 | 952,332 | u614576698 | cpp |
p03160 | /*
███╗ ███╗ █████╗ ███████╗███╗ ███╗ ██████╗ ██╗
██╗██████╗ ███████╗ █████╗ ███╗ ███╗██████╗ ██╗ ██╗ ████╗
████║██╔══██╗╚════██║████╗ ████║██╔═══██╗██║ ██║██╔══██╗╚════██║██╔══██╗████╗
████║██╔══██╗╚██╗ ██╔╝ ██╔████╔██║███████║ ██╔╝██╔████╔██║██║ ██║██║
██║██║ ██║ ██╔╝███████║██╔████╔██║██║ ██║ ╚████╔╝ ██║╚██╔╝██║██╔══██║
██╔╝ ██║╚██╔╝██║██║ ██║██║ ██║██║ ██║ ██╔╝ ██╔══██║██║╚██╔╝██║██║ ██║
╚██╔╝ ██║ ╚═╝ ██║██║ ██║ ██║ ██║ ╚═╝ ██║╚██████╔╝╚██████╔╝██████╔╝██╗██║
██║ ██║██║ ╚═╝ ██║██████╔╝ ██║ ╚═╝ ╚═╝╚═╝ ╚═╝ ╚═╝ ╚═╝ ╚═╝
╚═════╝ ╚═════╝ ╚═════╝ ╚═╝╚═╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚═════╝ ╚═╝
“Nobody but you have to believe in your dreams to make
them a reality.” ― Germany Kent
*/
#define _CRT_SECURE_NO_WARNINGS
#include <bits/stdc++.h>
using namespace std;
#define Ma7moud_7amdy \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL)
#define Open_Sesame Open()
#define pb push_back
#define all(v) ((v).begin()), ((v).end())
#define allr(v) ((v).rbegin()), ((v).rend())
#define sz(v) ((int)((v).size()))
#define clr(arr, x) memset(arr, x, sizeof arr)
#define endl "\n"
#define Accepted 0
#define watch(x) cout << #x << " = " << x << endl;
#define un_map unordered_map
#define RT(x) return cout << (x), 0;
#define sc(a) scanf("%d", &a)
#define scll(x) scanf("%I64d", &x)
#define scan(s) scanf("%[^\n]%*c", &s)
#define pr(s) printf("%s", s.c_str()); // print string
typedef long long ll;
typedef unsigned long long ull;
const double PI = acos(-1.0);
const double EPS = -1e-2;
const int dx[] = {1, 0, -1, 0, 1, 1, -1, -1};
const int dy[] = {0, 1, 0, -1, 1, -1, 1, -1};
const ll mod = 1000000007;
const int Mx = INT_MAX;
const int Mn = INT_MIN;
const ll MX = LLONG_MAX;
const ll MN = LLONG_MIN;
const int N = 1e5 + 1;
void Open() {
#ifndef ONLINE_JUDGE
freopen("Input.txt", "r", stdin);
freopen("Output.txt", "w", stdout);
#endif
}
int n, k;
int mem[N];
vector<int> v;
int solve(int i) {
int &ret = mem[i];
if (~ret)
return ret;
ret = Mx;
if (i + 1 < n)
ret = min(ret, solve(i + 1) + abs(v[i] - v[i + 1]));
if (i + 2 < n)
ret = min(ret, solve(i + 2) + abs(v[i] - v[i + 2]));
ret = ret == Mx ? 0 : ret;
return ret;
}
int main() {
Ma7moud_7amdy;
Open_Sesame;
clr(mem, -1);
cin >> n;
v = vector<int>(n);
for (int i = 0; i < n; i++)
cin >> v[i];
cout << solve(0);
return Accepted;
} | /*
███╗ ███╗ █████╗ ███████╗███╗ ███╗ ██████╗ ██╗
██╗██████╗ ███████╗ █████╗ ███╗ ███╗██████╗ ██╗ ██╗ ████╗
████║██╔══██╗╚════██║████╗ ████║██╔═══██╗██║ ██║██╔══██╗╚════██║██╔══██╗████╗
████║██╔══██╗╚██╗ ██╔╝ ██╔████╔██║███████║ ██╔╝██╔████╔██║██║ ██║██║
██║██║ ██║ ██╔╝███████║██╔████╔██║██║ ██║ ╚████╔╝ ██║╚██╔╝██║██╔══██║
██╔╝ ██║╚██╔╝██║██║ ██║██║ ██║██║ ██║ ██╔╝ ██╔══██║██║╚██╔╝██║██║ ██║
╚██╔╝ ██║ ╚═╝ ██║██║ ██║ ██║ ██║ ╚═╝ ██║╚██████╔╝╚██████╔╝██████╔╝██╗██║
██║ ██║██║ ╚═╝ ██║██████╔╝ ██║ ╚═╝ ╚═╝╚═╝ ╚═╝ ╚═╝ ╚═╝ ╚═╝
╚═════╝ ╚═════╝ ╚═════╝ ╚═╝╚═╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚═════╝ ╚═╝
“Nobody but you have to believe in your dreams to make
them a reality.” ― Germany Kent
*/
#define _CRT_SECURE_NO_WARNINGS
#include <bits/stdc++.h>
using namespace std;
#define Ma7moud_7amdy \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL)
#define Open_Sesame Open()
#define pb push_back
#define all(v) ((v).begin()), ((v).end())
#define allr(v) ((v).rbegin()), ((v).rend())
#define sz(v) ((int)((v).size()))
#define clr(arr, x) memset(arr, x, sizeof arr)
#define endl "\n"
#define Accepted 0
#define watch(x) cout << #x << " = " << x << endl;
#define un_map unordered_map
#define RT(x) return cout << (x), 0;
#define sc(a) scanf("%d", &a)
#define scll(x) scanf("%I64d", &x)
#define scan(s) scanf("%[^\n]%*c", &s)
#define pr(s) printf("%s", s.c_str()); // print string
typedef long long ll;
typedef unsigned long long ull;
const double PI = acos(-1.0);
const double EPS = -1e-2;
const int dx[] = {1, 0, -1, 0, 1, 1, -1, -1};
const int dy[] = {0, 1, 0, -1, 1, -1, 1, -1};
const ll mod = 1000000007;
const int Mx = INT_MAX;
const int Mn = INT_MIN;
const ll MX = LLONG_MAX;
const ll MN = LLONG_MIN;
const int N = 1e5 + 1;
void Open() {
#ifndef ONLINE_JUDGE
freopen("Input.txt", "r", stdin);
freopen("Output.txt", "w", stdout);
#endif
}
int n, k;
int mem[N];
vector<int> v;
int solve(int i) {
int &ret = mem[i];
if (~ret)
return ret;
ret = Mx;
if (i + 1 < n)
ret = min(ret, solve(i + 1) + abs(v[i] - v[i + 1]));
if (i + 2 < n)
ret = min(ret, solve(i + 2) + abs(v[i] - v[i + 2]));
ret = ret == Mx ? 0 : ret;
return ret;
}
int main() {
Ma7moud_7amdy;
// Open_Sesame;
clr(mem, -1);
cin >> n;
v = vector<int>(n);
for (int i = 0; i < n; i++)
cin >> v[i];
cout << solve(0);
return Accepted;
} | [] | 952,338 | 952,339 | u801961010 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define M (int)1e9
#define pi 3.1415926536
#define all(a) a.begin(), a.end()
#define fastio \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define flp(i, x, y) for (long long int i = x; i < y; i++)
#define ll long long int
#define MOD (long long int)(1000000007)
vector<int> SieveOfEratosthenes(int n) {
vector<int> ans;
bool prime[n + 1];
memset(prime, true, sizeof(prime));
for (int p = 2; p * p <= n; p++)
if (prime[p] == true)
for (int i = p * p; i <= n; i += p)
prime[i] = false;
for (int p = 2; p <= n; p++)
if (prime[p])
ans.push_back(p);
return ans;
}
vector<int> fib(int n) {
vector<int> ans;
int x = 0, y = 1, l = 1;
ans.push_back(x);
ans.push_back(y);
while (l < n) {
l = x + y;
x = y;
y = l;
ans.push_back(l);
}
return ans;
}
bool isPrime(ll n) {
if (n <= 1)
return false;
if (n <= 3)
return true;
if (n % 2 == 0 || n % 3 == 0)
return false;
for (ll i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
long long power(int n, int k) {
if (k == 0)
return 1;
else
return (n * power(n, k - 1) % 1000000007);
}
long long nCr(int n, int r) {
if (n == r)
return 1;
else if (r == 0)
return 1;
else
return ((nCr(n - 1, r - 1) + nCr(n - 1, r)) % 998244353);
}
int sdigit(int x) {
int ans = 0;
while (x) {
ans += x % 10;
x /= 10;
}
return ans;
}
long long lcm(int a, int b) {
return ((long long)a * (long long)b) / __gcd(a, b);
}
pair<int, int> subArraySum(int arr[], int n, int sum) {
int curr_sum = arr[0], start = 0, i;
for (i = 1; i <= n; i++) {
while (curr_sum > sum && start < i - 1) {
curr_sum = curr_sum - arr[start];
start++;
}
if (curr_sum == sum) {
// cout << "Sum found between indexes "
// << start << " and " << i - 1;
return make_pair(start, i - 1);
}
if (i < n)
curr_sum = curr_sum + arr[i];
}
return make_pair(-1, -1);
}
int bs(int a[], int b, int l, int r) {
int mid = (l + r) / 2;
if (l > r)
return -1;
if (a[mid] == b || l == r)
return mid;
if (a[mid] > b)
return bs(a, b, l, mid - 1);
else
return bs(a, b, mid + 1, r);
}
int divideandconquerbc(int a[], int l, int r) {
if (l >= r)
return 0;
int mid = (l + r) / 2, ans = 0;
ans += divideandconquerbc(a, l, mid);
ans += divideandconquerbc(a, mid + 1, r);
int x = r - l + 1, y = mid - l + 1;
int c[x];
int i = 0, j = 0;
for (int k = 0; k < x; k++) {
if ((a[l + i] <= a[mid + 1 + j] && i < y) || j >= x - y) {
c[k] = a[l + i];
i++;
} else {
c[k] = a[mid + 1 + j];
j++;
ans += y - i;
}
// cout<<c[k]<<" "<<ans<<endl;
}
for (int k = l; k <= r; k++)
a[k] = c[k - l];
return ans;
}
void explore(bool a[], vector<vector<int>> adj, int u) {
if (a[u - 1])
return;
else
a[u - 1] = true;
for (int i = 0; i < adj[u - 1].size(); i++) {
explore(a, adj, adj[u - 1][i] + 1);
}
}
long long gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
double startTime;
double getCurrentTime() {
return ((double)clock() - startTime) / CLOCKS_PER_SEC;
}
/*int dfs(int u,int f)
{
depth[u]=depth[f]+1;size[u]=1;
for (int i=0;i<conj[u].size();++i)
{
if ((v=conj[u][i])==f)continue;
size[u]+=dfs(v,u);
}
det[u]=size[u]-depth[u];return size[u];*/
void out(ll n) {
string a, b;
cin >> a >> b;
vector<int> v1, v2;
a += '0';
b += '0';
flp(i, 1, n + 1) {
if (a[i] != a[i - 1])
v1.push_back(i);
if (b[i] != b[i - 1])
v2.push_back(i);
}
cout << v1.size() + v2.size() << " ";
flp(i, 0, v1.size()) cout << v1[i] << " ";
flp(i, 0, v2.size()) cout << v2[v2.size() - i - 1] << " ";
cout << "\n";
}
int point(char A, char B) {
if (A == B)
return 0;
if (A == 'R') {
if (B == 'P')
return -1;
else
return 1;
}
if (A == 'P') {
if (B == 'R')
return 1;
else
return -1;
}
else {
if (B == 'R')
return -1;
else
return 1;
}
}
/*int mex(int r[])
{
int n=sizeof(r)/sizeof(r[0]);
int b[n+1]={};
int st=0;
flp(i,0,n)
{
b[a[i]]=1;
while(b[st]==1)
st++;
}
return st;
}*/
/*ll modInverse(ll n, ll p)
{
return power(n, p-2, p);
}*/
int good(int n, string s, char ch) {
if (n == 1) {
if (s[0] == ch)
return 0;
else
return 1;
} else {
int f1 = 0, f2 = 0;
for (int i = 0; i < n / 2; i++) {
if (s[i] == ch)
f1++;
if (s[n - i - 1] == ch)
f2++;
}
string s1 = s.substr(n / 2, n);
int ans1 = (n / 2) - f1 + good(n / 2, s1, ch + 1);
string s2 = s.substr(0, n / 2);
int ans2 = (n / 2) - f2 + good(n / 2, s2, ch + 1);
return min(ans1, ans2);
}
}
int main() {
//#ifndef ONLINE_JUDGE
// freopen("input.txt","r",stdin);
// freopen("ou.txt","w",stdout);
//#endif
fastio long long int T, i, r,
c0 = 0, c1 = 0, c2 = 0, ctr, m, n, a, b, c, d, u, v, t, mx = 1, g, f, l1,
l2, sum = 0, o, m1, m2, x, x2, y1, y2, x1, y, k, p, num = 1, step, l, z;
// long double ar;
int k1, k2, k3, p1 = -1, p2 = -1, p3 = -1, p5 = -1, p4 = -1, j, pd = 0,
U = -1e9;
T = 1;
// cin>>T;
bool res = false;
while (T--) {
res = false;
cin >> n;
ll h[n + 1];
int f[n + 1];
int dp_cst[n + 1];
f[0] = 0;
flp(i, 1, n + 1) cin >> h[i];
f[1] = 0;
f[2] = h[2] - h[1];
flp(i, 3, n + 1) {
f[i] = min((abs(h[i] - h[i - 1]) + f[i - 1]),
(abs(h[i] - h[i - 2]) + f[i - 2]));
}
cout << f[n] << "\n";
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define M (int)1e9
#define pi 3.1415926536
#define all(a) a.begin(), a.end()
#define fastio \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define flp(i, x, y) for (long long int i = x; i < y; i++)
#define ll long long int
#define MOD (long long int)(1000000007)
vector<int> SieveOfEratosthenes(int n) {
vector<int> ans;
bool prime[n + 1];
memset(prime, true, sizeof(prime));
for (int p = 2; p * p <= n; p++)
if (prime[p] == true)
for (int i = p * p; i <= n; i += p)
prime[i] = false;
for (int p = 2; p <= n; p++)
if (prime[p])
ans.push_back(p);
return ans;
}
vector<int> fib(int n) {
vector<int> ans;
int x = 0, y = 1, l = 1;
ans.push_back(x);
ans.push_back(y);
while (l < n) {
l = x + y;
x = y;
y = l;
ans.push_back(l);
}
return ans;
}
bool isPrime(ll n) {
if (n <= 1)
return false;
if (n <= 3)
return true;
if (n % 2 == 0 || n % 3 == 0)
return false;
for (ll i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
long long power(int n, int k) {
if (k == 0)
return 1;
else
return (n * power(n, k - 1) % 1000000007);
}
long long nCr(int n, int r) {
if (n == r)
return 1;
else if (r == 0)
return 1;
else
return ((nCr(n - 1, r - 1) + nCr(n - 1, r)) % 998244353);
}
int sdigit(int x) {
int ans = 0;
while (x) {
ans += x % 10;
x /= 10;
}
return ans;
}
long long lcm(int a, int b) {
return ((long long)a * (long long)b) / __gcd(a, b);
}
pair<int, int> subArraySum(int arr[], int n, int sum) {
int curr_sum = arr[0], start = 0, i;
for (i = 1; i <= n; i++) {
while (curr_sum > sum && start < i - 1) {
curr_sum = curr_sum - arr[start];
start++;
}
if (curr_sum == sum) {
// cout << "Sum found between indexes "
// << start << " and " << i - 1;
return make_pair(start, i - 1);
}
if (i < n)
curr_sum = curr_sum + arr[i];
}
return make_pair(-1, -1);
}
int bs(int a[], int b, int l, int r) {
int mid = (l + r) / 2;
if (l > r)
return -1;
if (a[mid] == b || l == r)
return mid;
if (a[mid] > b)
return bs(a, b, l, mid - 1);
else
return bs(a, b, mid + 1, r);
}
int divideandconquerbc(int a[], int l, int r) {
if (l >= r)
return 0;
int mid = (l + r) / 2, ans = 0;
ans += divideandconquerbc(a, l, mid);
ans += divideandconquerbc(a, mid + 1, r);
int x = r - l + 1, y = mid - l + 1;
int c[x];
int i = 0, j = 0;
for (int k = 0; k < x; k++) {
if ((a[l + i] <= a[mid + 1 + j] && i < y) || j >= x - y) {
c[k] = a[l + i];
i++;
} else {
c[k] = a[mid + 1 + j];
j++;
ans += y - i;
}
// cout<<c[k]<<" "<<ans<<endl;
}
for (int k = l; k <= r; k++)
a[k] = c[k - l];
return ans;
}
void explore(bool a[], vector<vector<int>> adj, int u) {
if (a[u - 1])
return;
else
a[u - 1] = true;
for (int i = 0; i < adj[u - 1].size(); i++) {
explore(a, adj, adj[u - 1][i] + 1);
}
}
long long gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
double startTime;
double getCurrentTime() {
return ((double)clock() - startTime) / CLOCKS_PER_SEC;
}
/*int dfs(int u,int f)
{
depth[u]=depth[f]+1;size[u]=1;
for (int i=0;i<conj[u].size();++i)
{
if ((v=conj[u][i])==f)continue;
size[u]+=dfs(v,u);
}
det[u]=size[u]-depth[u];return size[u];*/
void out(ll n) {
string a, b;
cin >> a >> b;
vector<int> v1, v2;
a += '0';
b += '0';
flp(i, 1, n + 1) {
if (a[i] != a[i - 1])
v1.push_back(i);
if (b[i] != b[i - 1])
v2.push_back(i);
}
cout << v1.size() + v2.size() << " ";
flp(i, 0, v1.size()) cout << v1[i] << " ";
flp(i, 0, v2.size()) cout << v2[v2.size() - i - 1] << " ";
cout << "\n";
}
int point(char A, char B) {
if (A == B)
return 0;
if (A == 'R') {
if (B == 'P')
return -1;
else
return 1;
}
if (A == 'P') {
if (B == 'R')
return 1;
else
return -1;
}
else {
if (B == 'R')
return -1;
else
return 1;
}
}
/*int mex(int r[])
{
int n=sizeof(r)/sizeof(r[0]);
int b[n+1]={};
int st=0;
flp(i,0,n)
{
b[a[i]]=1;
while(b[st]==1)
st++;
}
return st;
}*/
/*ll modInverse(ll n, ll p)
{
return power(n, p-2, p);
}*/
int good(int n, string s, char ch) {
if (n == 1) {
if (s[0] == ch)
return 0;
else
return 1;
} else {
int f1 = 0, f2 = 0;
for (int i = 0; i < n / 2; i++) {
if (s[i] == ch)
f1++;
if (s[n - i - 1] == ch)
f2++;
}
string s1 = s.substr(n / 2, n);
int ans1 = (n / 2) - f1 + good(n / 2, s1, ch + 1);
string s2 = s.substr(0, n / 2);
int ans2 = (n / 2) - f2 + good(n / 2, s2, ch + 1);
return min(ans1, ans2);
}
}
int main() {
//#ifndef ONLINE_JUDGE
// freopen("input.txt","r",stdin);
// freopen("ou.txt","w",stdout);
//#endif
fastio long long int T, i, r,
c0 = 0, c1 = 0, c2 = 0, ctr, m, n, a, b, c, d, u, v, t, mx = 1, g, f, l1,
l2, sum = 0, o, m1, m2, x, x2, y1, y2, x1, y, k, p, num = 1, step, l, z;
// long double ar;
int k1, k2, k3, p1 = -1, p2 = -1, p3 = -1, p5 = -1, p4 = -1, j, pd = 0,
U = -1e9;
T = 1;
// cin>>T;
bool res = false;
while (T--) {
res = false;
cin >> n;
ll h[n + 1];
int f[n + 1];
int dp_cst[n + 1];
f[0] = 0;
flp(i, 1, n + 1) cin >> h[i];
f[1] = 0;
f[2] = abs(h[2] - h[1]);
flp(i, 3, n + 1) {
f[i] = min((abs(h[i] - h[i - 1]) + f[i - 1]),
(abs(h[i] - h[i - 2]) + f[i - 2]));
}
cout << f[n] << "\n";
}
return 0;
}
| [
"call.add",
"call.arguments.change"
] | 952,340 | 952,341 | u496612088 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
vector<int> v(n);
for (auto &i : v)
cin >> i;
vector<int> dp(n);
dp[n - 1] = 0;
dp[n - 2] = abs(v[n - 1] - v[n - 2]);
for (int i = n - 3; i >= 0; i--) {
int a = abs(v[i] - v[i + 1]);
int b = abs(v[i] - v[n + 2]);
dp[i] = min(a + dp[i + 1], b + dp[i + 2]);
}
cout << dp[0];
} | #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
vector<int> v(n);
for (auto &i : v)
cin >> i;
vector<int> dp(n);
dp[n - 1] = 0;
dp[n - 2] = abs(v[n - 1] - v[n - 2]);
for (int i = n - 3; i >= 0; i--) {
int a = abs(v[i] - v[i + 1]);
int b = abs(v[i] - v[i + 2]);
dp[i] = min(a + dp[i + 1], b + dp[i + 2]);
}
cout << dp[0];
} | [
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 952,342 | 952,343 | u867580039 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
vector<int> v(n);
for (auto &i : v)
cin >> i;
vector<int> dp(n);
dp[n - 1] = 0;
dp[n - 2] = abs(v[n - 1] - v[n - 2]);
for (int i = n - 3; i >= 0; i--) {
int a = abs(v[i] - v[i + 1]);
int b = abs(v[i] - v[n + 2]);
dp[i] = min(a + dp[i + 1], b + dp[i + 2]);
}
// for(auto i:dp) cout<<i<<" ";
cout << dp[0];
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
vector<int> v(n);
for (auto &i : v)
cin >> i;
vector<int> dp(n);
dp[n - 1] = 0;
dp[n - 2] = abs(v[n - 1] - v[n - 2]);
for (int i = n - 3; i >= 0; i--) {
int a = abs(v[i] - v[i + 1]);
int b = abs(v[i] - v[i + 2]);
dp[i] = min(a + dp[i + 1], b + dp[i + 2]);
}
cout << dp[0];
} | [
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 952,344 | 952,343 | u867580039 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
vector<int> v(n);
for (auto &i : v)
cin >> i;
vector<int> dp(n);
dp[n - 1] = 0;
dp[n - 2] = abs(v[n - 1] - v[n - 2]);
for (int i = n - 3; i >= 0; i--) {
int a = abs(v[i] - v[i + 1]);
int b = abs(v[i] - v[n + 2]);
dp[i] = min(a + dp[i + 1], b + dp[i + 2]);
}
// for(auto i:dp) cout<<i<<" ";
cout << dp[0];
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
vector<int> v(n);
for (auto &i : v)
cin >> i;
vector<int> dp(n);
dp[n - 1] = 0;
dp[n - 2] = abs(v[n - 1] - v[n - 2]);
for (int i = n - 3; i >= 0; i--) {
int a = abs(v[i] - v[i + 1]);
int b = abs(v[i] - v[i + 2]);
dp[i] = min(a + dp[i + 1], b + dp[i + 2]);
}
cout << dp[0];
}
| [
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 952,344 | 952,345 | u867580039 | cpp |
p03160 | #include <bits/stdc++.h>
#define INF 1e6
using namespace std;
int main() {
int n;
cin >> n;
vector<int> H(n);
for (int i = 0; i < n; ++i)
cin >> H[i];
vector<int> dp(n, INF);
dp[0] = 0;
for (int i = 0; i < n; ++i) {
for (int x : {1, 2}) {
if (i + x < n) {
dp[i + x] = min(dp[i + x], dp[i] + abs(H[i] - H[i + x]));
}
}
}
cout << dp[n - 1] << "\n";
} | #include <bits/stdc++.h>
#define INF 1e9 + 5
using namespace std;
int main() {
int n;
cin >> n;
vector<int> H(n);
for (int i = 0; i < n; ++i)
cin >> H[i];
vector<int> dp(n, INF);
dp[0] = 0;
for (int i = 0; i < n; ++i) {
for (int x : {1, 2}) {
if (i + x < n) {
dp[i + x] = min(dp[i + x], dp[i] + abs(H[i] - H[i + x]));
}
}
}
cout << dp[n - 1] << "\n";
} | [
"preprocessor.define.value.change",
"literal.float.change"
] | 952,348 | 952,349 | u023030760 | cpp |
p03160 | #include <cstdlib>
#include <iostream>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; ++i)
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 main() {
int n;
cin >> n;
vector<int> h(n);
rep(i, n) { cin >> h[i]; }
vector<int> dp(n);
dp[0] = 0;
dp[1] = 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];
}
| #include <cstdlib>
#include <iostream>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; ++i)
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 main() {
int n;
cin >> n;
vector<int> h(n);
rep(i, n) { cin >> h[i]; }
vector<int> dp(n);
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];
}
| [
"call.add",
"call.arguments.change"
] | 952,355 | 952,356 | u289381123 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> dp(n, INT_MAX);
int h[n];
for (int i = 0; i < n; i++) {
cin >> h[i];
}
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 1; j < 3; j++) {
if (i + j < n) {
dp[i + j] = min(dp[i + j], dp[i] + abs(h[i] - h[i + j]));
}
}
}
cout << h[n - 1];
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> dp(n, INT_MAX);
int h[n];
for (int i = 0; i < n; i++) {
cin >> h[i];
}
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 1; j < 3; j++) {
if (i + j < n) {
dp[i + j] = min(dp[i + j], dp[i] + abs(h[i] - h[i + j]));
}
}
}
cout << dp[n - 1];
return 0;
} | [
"identifier.change",
"io.output.change"
] | 952,362 | 952,363 | u942160556 | cpp |
p03160 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<bool> vb;
typedef vector<ull> vul;
typedef vector<pair<ll, ll>> vpl;
typedef pair<ll, ll> pl;
#define For(i, n) for (ll i = 0; i < n; i++)
#define len(n) (ll)(n).size()
#define Sort(a) sort(a.begin(), a.end())
ll dp[110];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll n;
cin >> n;
vl h(n + 2);
For(i, n) {
cin >> h[i];
dp[i] = 1e12;
}
h[n] = 0;
h[n + 1] = 0;
dp[0] = 0;
For(i, 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]));
}
cout << dp[n - 1];
return 0;
} | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<bool> vb;
typedef vector<ull> vul;
typedef vector<pair<ll, ll>> vpl;
typedef pair<ll, ll> pl;
#define For(i, n) for (ll i = 0; i < n; i++)
#define len(n) (ll)(n).size()
#define Sort(a) sort(a.begin(), a.end())
ll dp[100010];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll n;
cin >> n;
vl h(n + 2);
For(i, n) {
cin >> h[i];
dp[i] = 1e12;
}
h[n] = 0;
h[n + 1] = 0;
dp[0] = 0;
For(i, 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]));
}
cout << dp[n - 1];
return 0;
} | [
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 952,364 | 952,365 | u080077876 | cpp |
p03160 | #include <cmath>
#include <iostream>
using namespace std;
int min(int a, int b) {
if (a > b)
return b;
else
return a;
}
int cost(int n, int h[]) {
int DP[n + 1];
DP[1] = 0;
DP[2] = abs(h[1] - h[0]);
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])));
return DP[n];
}
int main() {
int n;
cin >> n;
int h[n + 1];
for (int i = 1; i < n + 1; i++)
cin >> h[i];
cout << cost(n, h);
// your code goes here
return 0;
} | #include <cmath>
#include <iostream>
using namespace std;
int min(int a, int b) {
if (a > b)
return b;
else
return a;
}
int cost(int n, int h[]) {
int DP[n + 1];
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])));
return DP[n];
}
int main() {
int n;
cin >> n;
int h[n + 1];
for (int i = 1; i < n + 1; i++)
cin >> h[i];
cout << cost(n, h);
// your code goes here
return 0;
} | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 952,368 | 952,369 | u706567482 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int minCost(int n, int cost[], int dp[]) {
if (n == 1) {
return 0;
}
if (n == 2) {
return abs(cost[1] - cost[0]);
}
if (dp[n] != -1) {
return dp[n];
}
int cost1 = abs(cost[n - 1] - cost[n - 2]) + minCost(n - 1, cost, dp);
int cost2 = abs(cost[n - 1] - cost[n - 3]) + minCost(n - 2, cost, dp);
dp[n] = min(cost1, cost2);
return dp[n];
}
int main() {
int n;
cin >> n;
int cost[n];
for (int i = 0; i < n; i++) {
cin >> cost[i];
}
int dp[100];
for (int i = 0; i < 100; i++) {
dp[i] = -1;
}
cout << minCost(n, cost, dp);
}
| #include <bits/stdc++.h>
using namespace std;
int minCost(int n, int cost[], int dp[]) {
if (n == 1) {
return 0;
}
if (n == 2) {
return abs(cost[1] - cost[0]);
}
if (dp[n] != -1) {
return dp[n];
}
int cost1 = abs(cost[n - 1] - cost[n - 2]) + minCost(n - 1, cost, dp);
int cost2 = abs(cost[n - 1] - cost[n - 3]) + minCost(n - 2, cost, dp);
dp[n] = min(cost1, cost2);
return dp[n];
}
int main() {
int n;
cin >> n;
int cost[n];
for (int i = 0; i < n; i++) {
cin >> cost[i];
}
int dp[n + 1];
for (int i = 0; i <= n; i++) {
dp[i] = -1;
}
cout << minCost(n, cost, dp);
}
| [
"identifier.replace.add",
"literal.replace.remove",
"control_flow.loop.for.condition.change"
] | 952,372 | 952,371 | u602983424 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> h(n);
for (int i = 0; i < n; i++)
cin >> h.at(i);
vector<int> cost(n, -1);
cost.at(0) = h.at(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;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> h(n);
for (int i = 0; i < n; i++)
cin >> h.at(i);
vector<int> cost(n, -1);
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.remove",
"call.arguments.change"
] | 952,375 | 952,376 | u284109563 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int n, arr[1000000];
long dp[1000000];
long solve(int i) {
if (i >= n - 1) {
return 0;
}
if (dp[i] != -1)
return dp[i];
if (i == n - 2)
dp[i] = abs(arr[i] - arr[i + 1]);
else
dp[i] = max(abs(arr[i] - arr[i + 1]) + solve(i + 1),
abs(arr[i] - arr[i + 2]) + solve(i + 2));
return dp[i];
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
memset(dp, -1, sizeof(dp));
cout << solve(0);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int n, arr[1000000];
long dp[1000000];
long solve(int i) {
if (i >= n - 1) {
return 0;
}
if (dp[i] != -1)
return dp[i];
if (i == n - 2)
dp[i] = abs(arr[i] - arr[i + 1]);
else
dp[i] = min(abs(arr[i] - arr[i + 1]) + solve(i + 1),
abs(arr[i] - arr[i + 2]) + solve(i + 2));
return dp[i];
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
memset(dp, -1, sizeof(dp));
cout << solve(0);
return 0;
}
| [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 952,379 | 952,380 | u941672501 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int mem[100005] = {-1};
vector<int> frog;
int dp(int n) {
if (n < 0) {
return 0;
}
if (n == 0) {
return 0;
}
if (n == 1) {
return abs(frog[1] - frog[0]);
}
if (mem[n] != -1) {
return -1;
}
int x = dp(n - 1);
int y = dp(n - 2);
int cost =
min(x + abs(frog[n] - frog[n - 1]), y + abs(frog[n] - frog[n - 2]));
mem[n] = cost;
return cost;
}
int main() {
int n;
cin >> n;
memset(mem, -1, sizeof(mem));
for (int i = 0; i < n; i++) {
int x;
cin >> x;
frog.push_back(x);
}
cout << dp(n - 1);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int mem[100005] = {-1};
vector<int> frog;
int dp(int n) {
if (n < 0) {
return 0;
}
if (n == 0) {
return 0;
}
if (n == 1) {
return abs(frog[1] - frog[0]);
}
if (mem[n] != -1) {
return mem[n];
}
int x = dp(n - 1);
int y = dp(n - 2);
int cost =
min(x + abs(frog[n] - frog[n - 1]), y + abs(frog[n] - frog[n - 2]));
mem[n] = cost;
return cost;
}
int main() {
int n;
cin >> n;
memset(mem, -1, sizeof(mem));
for (int i = 0; i < n; i++) {
int x;
cin >> x;
frog.push_back(x);
}
cout << dp(n - 1);
return 0;
} | [] | 952,385 | 952,386 | u774919576 | cpp |
p03160 | #include <cmath>
#include <iostream>
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];
for (int i = 0; i < n; i++) {
if (i == 0)
dp[i] = 0;
else if (i == 1)
dp[i] = abs(arr[i - 1] - arr[i - 2]);
else {
int temp1 = abs(arr[i] - arr[i - 1]) + dp[i - 1];
int temp2 = abs(arr[i] - arr[i - 2]) + dp[i - 2];
dp[i] = min(temp1, temp2);
}
}
cout << dp[n - 1] << endl;
return 0;
} | #include <cmath>
#include <iostream>
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];
for (int i = 0; i < n; i++) {
if (i == 0)
dp[i] = 0;
else if (i == 1)
dp[i] = abs(arr[i] - arr[i - 1]);
else {
int temp1 = abs(arr[i] - arr[i - 1]) + dp[i - 1];
int temp2 = abs(arr[i] - arr[i - 2]) + dp[i - 2];
dp[i] = min(temp1, temp2);
}
}
cout << dp[n - 1] << endl;
return 0;
} | [
"expression.operation.binary.remove",
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 952,389 | 952,390 | u047590349 | cpp |
p03160 | #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];
vector<int> dp(n);
dp[n - 2] = abs(v[n - 1] - v[n - 2]);
for (int i = n - 3; i >= 0; i++) {
dp[i] =
min(dp[i + 1] + abs(v[i + 1] - v[i]), dp[i + 2] + abs(v[i + 2] - v[i]));
}
cout << dp[0] << 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];
vector<int> dp(n);
dp[n - 2] = abs(v[n - 1] - v[n - 2]);
for (int i = n - 3; i >= 0; i--) {
dp[i] =
min(dp[i + 1] + abs(v[i + 1] - v[i]), dp[i + 2] + abs(v[i + 2] - v[i]));
}
cout << dp[0] << endl;
return 0;
}
| [] | 952,395 | 952,396 | u065541219 | cpp |
p03160 | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
using namespace std;
#define f first
#define s second
#define fastio \
ios_base::sync_with_stdio(false); \
cin.tie(0)
#define loop(i, a, b) for (int i = a; i < b; i++)
#define loopb(i, a, b) for (int i = a; i >= b; i--)
#define pb push_back
typedef long long int lli;
typedef pair<lli, lli> pii;
typedef vector<lli> vll;
// use to avoid collision
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
// http://xorshift.di.unimi.it/splitmix64.c
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
// for pair in unordered_map
struct hash_pair {
template <class T1, class T2> size_t operator()(const pair<T1, T2> &p) const {
auto hash1 = hash<T1>{}(p.first);
auto hash2 = hash<T2>{}(p.second);
return hash1 ^ hash2;
}
};
lli power(lli x, lli y) {
lli res = 1;
x = x;
while (y > 0) {
if (y & 1)
res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
lli solve() {
lli n;
cin >> n;
vll h(n), dp(n, 0);
loop(i, 0, n) cin >> h[i];
dp[0] = h[0];
dp[1] = abs(h[1] - h[0]);
loop(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] << "\n";
return 0;
}
int main() {
fastio;
lli t;
// cin>>t;
t = 1;
while (t > 0) {
t--;
solve();
}
} | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
using namespace std;
#define f first
#define s second
#define fastio \
ios_base::sync_with_stdio(false); \
cin.tie(0)
#define loop(i, a, b) for (int i = a; i < b; i++)
#define loopb(i, a, b) for (int i = a; i >= b; i--)
#define pb push_back
typedef long long int lli;
typedef pair<lli, lli> pii;
typedef vector<lli> vll;
// use to avoid collision
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
// http://xorshift.di.unimi.it/splitmix64.c
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
// for pair in unordered_map
struct hash_pair {
template <class T1, class T2> size_t operator()(const pair<T1, T2> &p) const {
auto hash1 = hash<T1>{}(p.first);
auto hash2 = hash<T2>{}(p.second);
return hash1 ^ hash2;
}
};
lli power(lli x, lli y) {
lli res = 1;
x = x;
while (y > 0) {
if (y & 1)
res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
lli solve() {
lli n;
cin >> n;
vll h(n), dp(n, 0);
loop(i, 0, n) cin >> h[i];
dp[0] = 0;
dp[1] = abs(h[1] - h[0]);
loop(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] << "\n";
return 0;
}
int main() {
fastio;
lli t;
// cin>>t;
t = 1;
while (t > 0) {
t--;
solve();
}
} | [] | 952,404 | 952,405 | u256247307 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int heights[N];
for (int i = 0; i < N; i++)
cin >> heights[i];
int dp[N];
dp[0] = 0;
for (int i = 1; i < 0; i++) {
int op1 = INT_MAX;
int op2 = INT_MAX;
if (i - 1 >= 0)
op1 = abs(heights[i] - heights[i - 1]) + dp[i - 1];
if (i - 2 >= 0)
op2 = abs(heights[i] - heights[i - 2]) + dp[i - 2];
dp[i] = min(op1, op2);
}
cout << dp[N - 1];
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int heights[N];
for (int i = 0; i < N; i++)
cin >> heights[i];
int dp[N];
dp[0] = 0;
for (int i = 1; i < N; i++) {
int op1 = INT_MAX;
int op2 = INT_MAX;
if (i - 1 >= 0)
op1 = abs(heights[i] - heights[i - 1]) + dp[i - 1];
if (i - 2 >= 0)
op2 = abs(heights[i] - heights[i - 2]) + dp[i - 2];
dp[i] = min(op1, op2);
}
cout << dp[N - 1];
return 0;
}
| [
"identifier.replace.add",
"literal.replace.remove",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 952,406 | 952,407 | u720046242 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int heights[N];
for (int i = 0; i < N; i++)
cin >> heights[i];
int dp[N];
dp[0] = 0;
for (int i = 1; i < N; i++) {
int op1 = INT_MAX;
int op2 = INT_MAX;
if (i - 1 >= 0)
op1 = abs(heights[i] - heights[i - 1]) + dp[i - 1];
if (i - 2 >= 0)
op2 = abs(heights[i] - heights[i - 2]) + dp[i - 2];
dp[i] = min(op1, op2);
}
cout << dp[N];
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int heights[N];
for (int i = 0; i < N; i++)
cin >> heights[i];
int dp[N];
dp[0] = 0;
for (int i = 1; i < N; i++) {
int op1 = INT_MAX;
int op2 = INT_MAX;
if (i - 1 >= 0)
op1 = abs(heights[i] - heights[i - 1]) + dp[i - 1];
if (i - 2 >= 0)
op2 = abs(heights[i] - heights[i - 2]) + dp[i - 2];
dp[i] = min(op1, op2);
}
cout << dp[N - 1];
return 0;
}
| [
"expression.operation.binary.add"
] | 952,408 | 952,407 | u720046242 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int heights[N];
for (int i = 0; i < N; i++)
cin >> heights[i];
int dp[N];
dp[0] = 0;
for (int i = 1; i < 0; i++) {
int op1 = INT_MAX;
int op2 = INT_MAX;
if (i - 1 >= 0)
op1 = abs(heights[i] - heights[i - 1]) + dp[i - 1];
if (i - 2 >= 0)
op2 = abs(heights[i] - heights[i - 2]) + dp[i - 2];
dp[i] = min(op1, op2);
}
cout << dp[N];
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int heights[N];
for (int i = 0; i < N; i++)
cin >> heights[i];
int dp[N];
dp[0] = 0;
for (int i = 1; i < N; i++) {
int op1 = INT_MAX;
int op2 = INT_MAX;
if (i - 1 >= 0)
op1 = abs(heights[i] - heights[i - 1]) + dp[i - 1];
if (i - 2 >= 0)
op2 = abs(heights[i] - heights[i - 2]) + dp[i - 2];
dp[i] = min(op1, op2);
}
cout << dp[N - 1];
return 0;
}
| [
"identifier.replace.add",
"literal.replace.remove",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 952,409 | 952,407 | u720046242 | cpp |
p03160 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <list>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using str = string;
using vl = vector<ll>;
using vs = vector<str>;
using listl = list<ll>;
#define min(A, B) min(static_cast<ll>(A), static_cast<ll>(B))
#define max(A, B) max(static_cast<ll>(A), static_cast<ll>(B))
#define all(x) (x).begin(), (x).end()
#define mp make_pair
#define _rep(i, m) for (ll i = 0, i_max = m; i < i_max; i++)
#define _erep(i, m) for (ll i = 0, i_max = m; i <= i_max; i++)
#define _nrep(i, b, m) for (ll i = b, i_max = m; i < i_max; i++)
#define _enrep(i, b, m) for (ll i = b, i_max = m; i <= i_max; i++)
#define _brep(i, m) for (ll i = m; i >= 0; i--)
#define _ebrep(i, b, e) for (ll i = b; i >= e; i--)
#define rep(m) _rep(i, m)
#define erep(m) _erep(i, m)
#define nrep(b, m) _nrep(i, b, m)
#define enrep(b, m) _enrep(i, b, m)
#define brep(m) _brep(i, m)
#define ebrep(b, e) _ebrep(i, b, e)
// modint: mod 計算を int を扱うように扱える構造体
template <int MOD> struct Fp {
ll val;
constexpr Fp(ll v = 0) noexcept : val(v % MOD) {
if (val < 0)
val += MOD;
}
constexpr int getmod() { return MOD; }
constexpr Fp operator-() const noexcept { return val ? MOD - val : 0; }
constexpr Fp operator+(const Fp &r) const noexcept { return Fp(*this) += r; }
constexpr Fp operator-(const Fp &r) const noexcept { return Fp(*this) -= r; }
constexpr Fp operator*(const Fp &r) const noexcept { return Fp(*this) *= r; }
constexpr Fp operator/(const Fp &r) const noexcept { return Fp(*this) /= r; }
constexpr Fp &operator+=(const Fp &r) noexcept {
val += r.val;
if (val >= MOD)
val -= MOD;
return *this;
}
constexpr Fp &operator-=(const Fp &r) noexcept {
val -= r.val;
if (val < 0)
val += MOD;
return *this;
}
constexpr Fp &operator*=(const Fp &r) noexcept {
val = val * r.val % MOD;
return *this;
}
constexpr Fp &operator/=(const Fp &r) noexcept {
ll a = r.val, b = MOD, u = 1, v = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
val = val * u % MOD;
if (val < 0)
val += MOD;
return *this;
}
constexpr bool operator==(const Fp &r) const noexcept {
return this->val == r.val;
}
constexpr bool operator!=(const Fp &r) const noexcept {
return this->val != r.val;
}
friend ostream &operator<<(ostream &os, const Fp<MOD> &x) noexcept {
return os << x.val;
}
friend constexpr Fp<MOD> modpow(const Fp<MOD> &a, ll n) noexcept {
if (n == 0)
return 1;
auto t = modpow(a, n / 2);
t = t * t;
if (n & 1)
t = t * a;
return t;
}
};
const int MOD = 1000000007;
using mint = Fp<MOD>;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
void in(ll &I) { cin >> I; }
void in(vl &I) {
for (auto &i : I) {
cin >> i;
}
}
void in(vs &I) {
for (auto &i : I) {
cin >> i;
}
}
void in(listl &I) {
for (auto &i : I) {
cin >> i;
}
}
void in(str &s) { cin >> s; }
void out(ll O) { cout << O; }
void out(vl &O) {
for (auto &o : O) {
cout << o << endl;
}
}
void rout(bool b, str True, str False) {
if (b)
cout << True.c_str();
else
cout << False.c_str();
}
const int INF = 1 << 29;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main() {
ll N;
cin >> N;
vl h(N);
in(h);
vl dp(N, 0);
dp[0] = 0;
dp[1] = h[1] - h[0];
nrep(2, N) {
dp[i] =
min(dp[i - 1] + abs(h[i] - h[i - 1]), dp[i - 2] + abs(h[i] - h[i - 2]));
}
cout << dp[N - 1] << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <list>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using str = string;
using vl = vector<ll>;
using vs = vector<str>;
using listl = list<ll>;
#define min(A, B) min(static_cast<ll>(A), static_cast<ll>(B))
#define max(A, B) max(static_cast<ll>(A), static_cast<ll>(B))
#define all(x) (x).begin(), (x).end()
#define mp make_pair
#define _rep(i, m) for (ll i = 0, i_max = m; i < i_max; i++)
#define _erep(i, m) for (ll i = 0, i_max = m; i <= i_max; i++)
#define _nrep(i, b, m) for (ll i = b, i_max = m; i < i_max; i++)
#define _enrep(i, b, m) for (ll i = b, i_max = m; i <= i_max; i++)
#define _brep(i, m) for (ll i = m; i >= 0; i--)
#define _ebrep(i, b, e) for (ll i = b; i >= e; i--)
#define rep(m) _rep(i, m)
#define erep(m) _erep(i, m)
#define nrep(b, m) _nrep(i, b, m)
#define enrep(b, m) _enrep(i, b, m)
#define brep(m) _brep(i, m)
#define ebrep(b, e) _ebrep(i, b, e)
// modint: mod 計算を int を扱うように扱える構造体
template <int MOD> struct Fp {
ll val;
constexpr Fp(ll v = 0) noexcept : val(v % MOD) {
if (val < 0)
val += MOD;
}
constexpr int getmod() { return MOD; }
constexpr Fp operator-() const noexcept { return val ? MOD - val : 0; }
constexpr Fp operator+(const Fp &r) const noexcept { return Fp(*this) += r; }
constexpr Fp operator-(const Fp &r) const noexcept { return Fp(*this) -= r; }
constexpr Fp operator*(const Fp &r) const noexcept { return Fp(*this) *= r; }
constexpr Fp operator/(const Fp &r) const noexcept { return Fp(*this) /= r; }
constexpr Fp &operator+=(const Fp &r) noexcept {
val += r.val;
if (val >= MOD)
val -= MOD;
return *this;
}
constexpr Fp &operator-=(const Fp &r) noexcept {
val -= r.val;
if (val < 0)
val += MOD;
return *this;
}
constexpr Fp &operator*=(const Fp &r) noexcept {
val = val * r.val % MOD;
return *this;
}
constexpr Fp &operator/=(const Fp &r) noexcept {
ll a = r.val, b = MOD, u = 1, v = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
val = val * u % MOD;
if (val < 0)
val += MOD;
return *this;
}
constexpr bool operator==(const Fp &r) const noexcept {
return this->val == r.val;
}
constexpr bool operator!=(const Fp &r) const noexcept {
return this->val != r.val;
}
friend ostream &operator<<(ostream &os, const Fp<MOD> &x) noexcept {
return os << x.val;
}
friend constexpr Fp<MOD> modpow(const Fp<MOD> &a, ll n) noexcept {
if (n == 0)
return 1;
auto t = modpow(a, n / 2);
t = t * t;
if (n & 1)
t = t * a;
return t;
}
};
const int MOD = 1000000007;
using mint = Fp<MOD>;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
void in(ll &I) { cin >> I; }
void in(vl &I) {
for (auto &i : I) {
cin >> i;
}
}
void in(vs &I) {
for (auto &i : I) {
cin >> i;
}
}
void in(listl &I) {
for (auto &i : I) {
cin >> i;
}
}
void in(str &s) { cin >> s; }
void out(ll O) { cout << O; }
void out(vl &O) {
for (auto &o : O) {
cout << o << endl;
}
}
void rout(bool b, str True, str False) {
if (b)
cout << True.c_str();
else
cout << False.c_str();
}
const int INF = 1 << 29;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main() {
ll N;
cin >> N;
vl h(N);
in(h);
vl dp(N, 0);
dp[0] = 0;
dp[1] = abs(h[1] - h[0]);
nrep(2, N) {
dp[i] =
min(dp[i - 1] + abs(h[i] - h[i - 1]), dp[i - 2] + abs(h[i] - h[i - 2]));
}
cout << dp[N - 1] << endl;
return 0;
}
| [
"call.add",
"call.arguments.change"
] | 952,413 | 952,414 | u288035794 | cpp |
p03160 | // thuanqvbn03
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 100005;
const int oo = 1e9;
int n;
int h[MaxN], dp[MaxN];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> h[i];
dp[i] = oo;
}
dp[1] = 0;
for (int i = 1; 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];
return 0;
} | // thuanqvbn03
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 100005;
const int oo = 1e9;
int n;
int h[MaxN], dp[MaxN];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> h[i];
dp[i] = oo;
}
dp[1] = 0;
for (int i = 1; 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];
return 0;
} | [
"assignment.value.change",
"call.arguments.change"
] | 952,415 | 952,416 | u124636763 | cpp |
p03160 | #include <cmath>
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int dp[n];
dp[0] = a[0];
dp[1] = abs(a[1] - a[0]);
for (int i = 2; i < n; i++) {
dp[i] =
min(dp[i - 2] + abs(a[i] - a[i - 2]), dp[i - 1] + abs(a[i] - a[i - 1]));
}
cout << dp[n - 1];
}
| #include <cmath>
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int dp[n];
dp[0] = 0;
dp[1] = abs(a[1] - a[0]);
for (int i = 2; i < n; i++) {
dp[i] =
min(dp[i - 2] + abs(a[i] - a[i - 2]), dp[i - 1] + abs(a[i] - a[i - 1]));
}
cout << dp[n - 1];
}
| [] | 952,417 | 952,418 | u202494171 | cpp |
p03160 | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/detail/standard_policies.hpp>
using namespace std;
using namespace __gnu_pbds;
template <typename T>
using indexed_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define all(v) ((v).begin()), ((v).end())
#define SZ(v) ((int)((v).size()))
#define clr(v, d) memset(v, d, sizeof(v))
#define has(c, i) ((c).find(i) != end(c))
#define has_str(s, c) ((s).find(c) != string::npos)
typedef long long ll;
int main() {
#ifdef LOCAL
// freopen("input.txt", "r", stdin);
#endif
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n;
cin >> n;
vector<int> h(n);
for (int &i : h)
cin >> i;
vector<int> dp(n);
dp[0] = 0;
dp[1] = abs(h[0] - h[1]);
for (int i = 2; i < n; ++i) {
dp[i] = min(dp[i - 1] + abs(h[i - 1] - h[i]),
dp[i - 2] + abs(h[i - 2] - h[i - 1]));
}
cout << dp[n - 1];
return 0;
} | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/detail/standard_policies.hpp>
using namespace std;
using namespace __gnu_pbds;
template <typename T>
using indexed_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define all(v) ((v).begin()), ((v).end())
#define SZ(v) ((int)((v).size()))
#define clr(v, d) memset(v, d, sizeof(v))
#define has(c, i) ((c).find(i) != end(c))
#define has_str(s, c) ((s).find(c) != string::npos)
typedef long long ll;
int main() {
#ifdef LOCAL
// freopen("input.txt", "r", stdin);
#endif
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n;
cin >> n;
vector<int> h(n);
for (int &i : h)
cin >> i;
vector<int> dp(n);
dp[0] = 0;
dp[1] = abs(h[0] - h[1]);
for (int i = 2; i < n; ++i) {
dp[i] =
min(dp[i - 1] + abs(h[i - 1] - h[i]), dp[i - 2] + abs(h[i - 2] - h[i]));
}
cout << dp[n - 1];
return 0;
} | [
"expression.operation.binary.remove"
] | 952,421 | 952,422 | u931971262 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int dp[n + 1] = {0};
dp[1] = 0;
dp[2] = abs(a[0] - a[1]);
for (int i = 3; i <= n; i++) {
dp[i] =
min(dp[i - 2] + abs(a[i] - a[i - 2]), dp[i - 1] + abs(a[i] - a[i - 1]));
}
cout << dp[n] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int dp[n + 1] = {0};
dp[0] = 0;
dp[1] = abs(a[0] - a[1]);
for (int i = 2; i < n; i++) {
dp[i] =
min(dp[i - 2] + abs(a[i] - a[i - 2]), dp[i - 1] + abs(a[i] - a[i - 1]));
}
cout << dp[n - 1] << endl;
return 0;
} | [
"literal.number.change",
"assignment.variable.change",
"variable_access.subscript.index.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.opera... | 952,425 | 952,426 | u067276037 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, temp;
cin >> n;
vector<int> h(n, 0);
for (int i = 0; i < n; i++) {
cin >> temp;
h[i] = temp;
}
vector<int> dp(n + 1, 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]));
}
return dp[n - 1];
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, temp;
cin >> n;
vector<int> h(n, 0);
for (int i = 0; i < n; i++) {
cin >> temp;
h[i] = temp;
}
vector<int> dp(n + 1, 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];
} | [
"io.output.change"
] | 952,427 | 952,428 | u061594873 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
cin >> n;
vector<int> dp(n, INT_MAX), arr(n, 0);
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
dp[0] = arr[0];
dp[1] = abs(arr[1] - arr[0]);
for (int i = 2; i < n; i++) {
dp[i] = min(dp[i - 1] + abs(arr[i] - arr[i - 1]),
dp[i - 2] + abs(arr[i] - arr[i - 2]));
}
cout << dp[n - 1] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
cin >> n;
vector<int> dp(n, INT_MAX), arr(n, 0);
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
dp[0] = 0;
dp[1] = abs(arr[1] - arr[0]);
for (int i = 2; i < n; i++) {
dp[i] = min(dp[i - 1] + abs(arr[i] - arr[i - 1]),
dp[i - 2] + abs(arr[i] - arr[i - 2]));
}
cout << dp[n - 1] << endl;
return 0;
} | [] | 952,429 | 952,430 | u061594873 | cpp |
p03160 | #include <algorithm>
#include <assert.h>
#include <bits/stdc++.h>
#include <bits/stdtr1c++.h>
#include <bitset>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <time.h>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
const int N = 100005;
const int MOD = 1000000007;
int mi(int a, int b) {
if (a < b)
return a;
return b;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int h[n + 1];
for (int i = 1; i <= n; i++) {
cin >> h[i];
}
int minu[n];
minu[1] = h[1];
minu[2] = abs(h[2] - h[1]);
for (int i = 3; i <= n; i++) {
minu[i] = mi(minu[i - 1] + abs(h[i] - h[i - 1]),
minu[i - 2] + abs(h[i] - h[i - 2]));
}
cout << minu[n];
return 0;
}
| #include <algorithm>
#include <assert.h>
#include <bits/stdc++.h>
#include <bits/stdtr1c++.h>
#include <bitset>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <time.h>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
const int N = 100005;
const int MOD = 1000000007;
int mi(int a, int b) {
if (a < b)
return a;
return b;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int h[n + 1];
for (int i = 1; i <= n; i++) {
cin >> h[i];
}
int minu[n];
minu[1] = 0;
minu[2] = abs(h[2] - h[1]);
for (int i = 3; i <= n; i++) {
minu[i] = mi(minu[i - 1] + abs(h[i] - h[i - 1]),
minu[i - 2] + abs(h[i] - h[i - 2]));
}
cout << minu[n];
return 0;
}
| [
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add"
] | 952,433 | 952,434 | u906385259 | cpp |
p03160 | #include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
//
// int n, m;
// bool vaild(int i, int j)
//{
// return i >= 0 && i <= n - 1 && j >= 0 && j <= m - 1;
//}
//
// int xcor[] = { 1,-1 , 0 , 0 };
// int ycor[] = { 0,0 , 1 , -1 };
//
//
// long long maxSubArraySum(vector<long long >& a, long long start, long long
// end)
//{
// long long max_so_far = a[start];
// long long curr_max = a[start];
// for (int i = 0; i < end; i++)
// {
// curr_max += a[i];
// if (curr_max < a[i])
// {
// curr_max = a[i];
// }
// max_so_far = max(max_so_far, curr_max);
// }
// return max_so_far;
//}
//
//
// long long gcd(long long a, long long b)
//{
// if (b == 0)
// return a;
// return gcd(b, a % b);
//
//}
//
//
// long long lcm(long long a, long long b)
//{
// return a * b / gcd(a, b);
//}
//
//
//
// int fastpow(int b, int p) {
// if (p == 1) return b;
// int sq = pow(b, p / 2);
// sq = sq * sq;
//
// if (p % 2 == 1)
// sq = sq * b;
//
// return sq;
//}
//
// int grid[500][500];
// int n = 50;
// int targetx = 5;
// int targety = 5;
//
// int maxSum(int i, int j)
//{
// if (i < 0 || i >= n || j < 0 || j >= n )
// {
// return 0;
// }
// if (i == targetx && j == targety)
// {
// return grid[i][j];
// }
// int sum1;
// int sum2;
// if (dp[i][j+1] != -1)
// {
// return dp[i][j + 1];
// }
// if (dp[i+1][j] != -1)
// {
// return dp[i+1][j ];
// }
// sum1 = maxSum(i, j + 1);
// sum2 = maxSum(i, j + 1);
// return dp[i][j] = grid[i][j] + max(sum1, sum2);
//}
// int dp[500][500];
// int RecuSum(int index, int curSum)
//{
// if (dp[index][curSum] = -1)
// {
// return dp[index][curSum];
// }
// if (index == sum.size() )
// {
// return curSum % 7 == 0;
// }
// if (dp[index][curSum] = RecuSum(index + 1, curSum + sum[index]) ||
// RecuSum(index + 1, curSum - sum[index]))
// {
// return dp[index][curSum];
// }
// return dp[index][curSum];
//}
// 0 0 -> 1 1
// 1 1 -> 2 6
// const int MAX = 21;
// const int N = 3;
// int minimumCost = INT_MAX;
// int r[MAX];
// int g[MAX];
// int b[MAX];
// int dp[MAX][MAX];
//
// int minCost (int lastColor , int i)
//{
//
// if (i == N)
// {
// return 0;
// }
// int& minimumCost = dp{i][lastColor];
// if (minimumCost != -1)
// {
// return minimumCost;
// }
//
// minimumCost = INT_MAX;
//
// if(minimumCost)
// if (lastColor != 0)
// {
// minimumCost = min(r[i]+minCost(0, i + 1) , minimumCost);
// }
// if (lastColor != 1 )
// {
// minimumCost = min(g[i]+minCost(1, i + 1), minimumCost);
//
// }
// if (lastColor != 2)
// {
// minimumCost = min(b[i]+minCost(2, i + 1), minimumCost);
//
// }
// return minimumCost;
//
//}
// int dp[5][101];
// int minimumReset(int index, int parenttype)
//{
// if (index == n)
// {
// return 0;
// }
//
// int &r = dp[parenttype][index];
// if (r != -1)
// {
// return r;
// }
// r = 0;
//
//
// if (parenttype != 3 || elements[index] == 0)
// {
// r = max(minimumReset(index + 1, 3), r);
//
// }
//
//
// if ((elements[index] == 1 || elements[index] == 3) && parenttype != 1)
// r = max(minimumReset(index + 1, 1)+1, r);
//
// if ((elements[index] == 2 || elements[index] == 3 )&& parenttype != 2)
// r = max(minimumReset(index + 1, 2)+1, r);
//
// return r;
//
//}
//
int n;
long long elements[100001];
long long dp[101];
long long minCost(int index) {
if (index == n - 1) {
return 0;
}
if (dp[index] != -1) {
return dp[index];
}
long long r = LLONG_MAX;
if (index + 1 < n) {
r = min(minCost(index + 1) + abs(elements[index] - elements[index + 1]), r);
}
if (index + 2 < n) {
r = min(minCost(index + 2) + abs(elements[index] - elements[index + 2]), r);
}
dp[index] = r;
return r;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
elements[i] = a;
}
for (int i = 0; i < 101; i++) {
dp[i] = -1;
}
cout << minCost(0);
}
| #include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
//
// int n, m;
// bool vaild(int i, int j)
//{
// return i >= 0 && i <= n - 1 && j >= 0 && j <= m - 1;
//}
//
// int xcor[] = { 1,-1 , 0 , 0 };
// int ycor[] = { 0,0 , 1 , -1 };
//
//
// long long maxSubArraySum(vector<long long >& a, long long start, long long
// end)
//{
// long long max_so_far = a[start];
// long long curr_max = a[start];
// for (int i = 0; i < end; i++)
// {
// curr_max += a[i];
// if (curr_max < a[i])
// {
// curr_max = a[i];
// }
// max_so_far = max(max_so_far, curr_max);
// }
// return max_so_far;
//}
//
//
// long long gcd(long long a, long long b)
//{
// if (b == 0)
// return a;
// return gcd(b, a % b);
//
//}
//
//
// long long lcm(long long a, long long b)
//{
// return a * b / gcd(a, b);
//}
//
//
//
// int fastpow(int b, int p) {
// if (p == 1) return b;
// int sq = pow(b, p / 2);
// sq = sq * sq;
//
// if (p % 2 == 1)
// sq = sq * b;
//
// return sq;
//}
//
// int grid[500][500];
// int n = 50;
// int targetx = 5;
// int targety = 5;
//
// int maxSum(int i, int j)
//{
// if (i < 0 || i >= n || j < 0 || j >= n )
// {
// return 0;
// }
// if (i == targetx && j == targety)
// {
// return grid[i][j];
// }
// int sum1;
// int sum2;
// if (dp[i][j+1] != -1)
// {
// return dp[i][j + 1];
// }
// if (dp[i+1][j] != -1)
// {
// return dp[i+1][j ];
// }
// sum1 = maxSum(i, j + 1);
// sum2 = maxSum(i, j + 1);
// return dp[i][j] = grid[i][j] + max(sum1, sum2);
//}
// int dp[500][500];
// int RecuSum(int index, int curSum)
//{
// if (dp[index][curSum] = -1)
// {
// return dp[index][curSum];
// }
// if (index == sum.size() )
// {
// return curSum % 7 == 0;
// }
// if (dp[index][curSum] = RecuSum(index + 1, curSum + sum[index]) ||
// RecuSum(index + 1, curSum - sum[index]))
// {
// return dp[index][curSum];
// }
// return dp[index][curSum];
//}
// 0 0 -> 1 1
// 1 1 -> 2 6
// const int MAX = 21;
// const int N = 3;
// int minimumCost = INT_MAX;
// int r[MAX];
// int g[MAX];
// int b[MAX];
// int dp[MAX][MAX];
//
// int minCost (int lastColor , int i)
//{
//
// if (i == N)
// {
// return 0;
// }
// int& minimumCost = dp{i][lastColor];
// if (minimumCost != -1)
// {
// return minimumCost;
// }
//
// minimumCost = INT_MAX;
//
// if(minimumCost)
// if (lastColor != 0)
// {
// minimumCost = min(r[i]+minCost(0, i + 1) , minimumCost);
// }
// if (lastColor != 1 )
// {
// minimumCost = min(g[i]+minCost(1, i + 1), minimumCost);
//
// }
// if (lastColor != 2)
// {
// minimumCost = min(b[i]+minCost(2, i + 1), minimumCost);
//
// }
// return minimumCost;
//
//}
// int dp[5][101];
// int minimumReset(int index, int parenttype)
//{
// if (index == n)
// {
// return 0;
// }
//
// int &r = dp[parenttype][index];
// if (r != -1)
// {
// return r;
// }
// r = 0;
//
//
// if (parenttype != 3 || elements[index] == 0)
// {
// r = max(minimumReset(index + 1, 3), r);
//
// }
//
//
// if ((elements[index] == 1 || elements[index] == 3) && parenttype != 1)
// r = max(minimumReset(index + 1, 1)+1, r);
//
// if ((elements[index] == 2 || elements[index] == 3 )&& parenttype != 2)
// r = max(minimumReset(index + 1, 2)+1, r);
//
// return r;
//
//}
//
int n;
int elements[100001];
long long dp[100001];
long long minCost(int index) {
if (index == n - 1) {
return 0;
}
if (dp[index] != -1) {
return dp[index];
}
long long r = LLONG_MAX;
if (index + 1 < n) {
r = min(minCost(index + 1) + abs(elements[index] - elements[index + 1]), r);
}
if (index + 2 < n) {
r = min(minCost(index + 2) + abs(elements[index] - elements[index + 2]), r);
}
dp[index] = r;
return r;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
elements[i] = a;
}
for (int i = 0; i < 100001; i++) {
dp[i] = -1;
}
cout << minCost(0);
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.narrow.change",
"literal.number.change",
"variable_declaration.array_dimensions.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 952,435 | 952,436 | u927144274 | cpp |
p03160 | #include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
//
// int n, m;
// bool vaild(int i, int j)
//{
// return i >= 0 && i <= n - 1 && j >= 0 && j <= m - 1;
//}
//
// int xcor[] = { 1,-1 , 0 , 0 };
// int ycor[] = { 0,0 , 1 , -1 };
//
//
// long long maxSubArraySum(vector<long long >& a, long long start, long long
// end)
//{
// long long max_so_far = a[start];
// long long curr_max = a[start];
// for (int i = 0; i < end; i++)
// {
// curr_max += a[i];
// if (curr_max < a[i])
// {
// curr_max = a[i];
// }
// max_so_far = max(max_so_far, curr_max);
// }
// return max_so_far;
//}
//
//
// long long gcd(long long a, long long b)
//{
// if (b == 0)
// return a;
// return gcd(b, a % b);
//
//}
//
//
// long long lcm(long long a, long long b)
//{
// return a * b / gcd(a, b);
//}
//
//
//
// int fastpow(int b, int p) {
// if (p == 1) return b;
// int sq = pow(b, p / 2);
// sq = sq * sq;
//
// if (p % 2 == 1)
// sq = sq * b;
//
// return sq;
//}
//
// int grid[500][500];
// int n = 50;
// int targetx = 5;
// int targety = 5;
//
// int maxSum(int i, int j)
//{
// if (i < 0 || i >= n || j < 0 || j >= n )
// {
// return 0;
// }
// if (i == targetx && j == targety)
// {
// return grid[i][j];
// }
// int sum1;
// int sum2;
// if (dp[i][j+1] != -1)
// {
// return dp[i][j + 1];
// }
// if (dp[i+1][j] != -1)
// {
// return dp[i+1][j ];
// }
// sum1 = maxSum(i, j + 1);
// sum2 = maxSum(i, j + 1);
// return dp[i][j] = grid[i][j] + max(sum1, sum2);
//}
// int dp[500][500];
// int RecuSum(int index, int curSum)
//{
// if (dp[index][curSum] = -1)
// {
// return dp[index][curSum];
// }
// if (index == sum.size() )
// {
// return curSum % 7 == 0;
// }
// if (dp[index][curSum] = RecuSum(index + 1, curSum + sum[index]) ||
// RecuSum(index + 1, curSum - sum[index]))
// {
// return dp[index][curSum];
// }
// return dp[index][curSum];
//}
// 0 0 -> 1 1
// 1 1 -> 2 6
// const int MAX = 21;
// const int N = 3;
// int minimumCost = INT_MAX;
// int r[MAX];
// int g[MAX];
// int b[MAX];
// int dp[MAX][MAX];
//
// int minCost (int lastColor , int i)
//{
//
// if (i == N)
// {
// return 0;
// }
// int& minimumCost = dp{i][lastColor];
// if (minimumCost != -1)
// {
// return minimumCost;
// }
//
// minimumCost = INT_MAX;
//
// if(minimumCost)
// if (lastColor != 0)
// {
// minimumCost = min(r[i]+minCost(0, i + 1) , minimumCost);
// }
// if (lastColor != 1 )
// {
// minimumCost = min(g[i]+minCost(1, i + 1), minimumCost);
//
// }
// if (lastColor != 2)
// {
// minimumCost = min(b[i]+minCost(2, i + 1), minimumCost);
//
// }
// return minimumCost;
//
//}
// int dp[5][101];
// int minimumReset(int index, int parenttype)
//{
// if (index == n)
// {
// return 0;
// }
//
// int &r = dp[parenttype][index];
// if (r != -1)
// {
// return r;
// }
// r = 0;
//
//
// if (parenttype != 3 || elements[index] == 0)
// {
// r = max(minimumReset(index + 1, 3), r);
//
// }
//
//
// if ((elements[index] == 1 || elements[index] == 3) && parenttype != 1)
// r = max(minimumReset(index + 1, 1)+1, r);
//
// if ((elements[index] == 2 || elements[index] == 3 )&& parenttype != 2)
// r = max(minimumReset(index + 1, 2)+1, r);
//
// return r;
//
//}
//
int n;
long long elements[100001];
long long dp[101];
long long minCost(int index) {
if (index == n - 1) {
return 0;
}
if (dp[index] != -1) {
return dp[index];
}
long long r = INT_MAX;
if (index + 1 < n) {
r = min(minCost(index + 1) + abs(elements[index] - elements[index + 1]), r);
}
if (index + 2 < n) {
r = min(minCost(index + 2) + abs(elements[index] - elements[index + 2]), r);
}
dp[index] = r;
return r;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
elements[i] = a;
}
for (int i = 0; i < 100; i++) {
dp[i] = -1;
}
cout << minCost(0);
}
| #include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
//
// int n, m;
// bool vaild(int i, int j)
//{
// return i >= 0 && i <= n - 1 && j >= 0 && j <= m - 1;
//}
//
// int xcor[] = { 1,-1 , 0 , 0 };
// int ycor[] = { 0,0 , 1 , -1 };
//
//
// long long maxSubArraySum(vector<long long >& a, long long start, long long
// end)
//{
// long long max_so_far = a[start];
// long long curr_max = a[start];
// for (int i = 0; i < end; i++)
// {
// curr_max += a[i];
// if (curr_max < a[i])
// {
// curr_max = a[i];
// }
// max_so_far = max(max_so_far, curr_max);
// }
// return max_so_far;
//}
//
//
// long long gcd(long long a, long long b)
//{
// if (b == 0)
// return a;
// return gcd(b, a % b);
//
//}
//
//
// long long lcm(long long a, long long b)
//{
// return a * b / gcd(a, b);
//}
//
//
//
// int fastpow(int b, int p) {
// if (p == 1) return b;
// int sq = pow(b, p / 2);
// sq = sq * sq;
//
// if (p % 2 == 1)
// sq = sq * b;
//
// return sq;
//}
//
// int grid[500][500];
// int n = 50;
// int targetx = 5;
// int targety = 5;
//
// int maxSum(int i, int j)
//{
// if (i < 0 || i >= n || j < 0 || j >= n )
// {
// return 0;
// }
// if (i == targetx && j == targety)
// {
// return grid[i][j];
// }
// int sum1;
// int sum2;
// if (dp[i][j+1] != -1)
// {
// return dp[i][j + 1];
// }
// if (dp[i+1][j] != -1)
// {
// return dp[i+1][j ];
// }
// sum1 = maxSum(i, j + 1);
// sum2 = maxSum(i, j + 1);
// return dp[i][j] = grid[i][j] + max(sum1, sum2);
//}
// int dp[500][500];
// int RecuSum(int index, int curSum)
//{
// if (dp[index][curSum] = -1)
// {
// return dp[index][curSum];
// }
// if (index == sum.size() )
// {
// return curSum % 7 == 0;
// }
// if (dp[index][curSum] = RecuSum(index + 1, curSum + sum[index]) ||
// RecuSum(index + 1, curSum - sum[index]))
// {
// return dp[index][curSum];
// }
// return dp[index][curSum];
//}
// 0 0 -> 1 1
// 1 1 -> 2 6
// const int MAX = 21;
// const int N = 3;
// int minimumCost = INT_MAX;
// int r[MAX];
// int g[MAX];
// int b[MAX];
// int dp[MAX][MAX];
//
// int minCost (int lastColor , int i)
//{
//
// if (i == N)
// {
// return 0;
// }
// int& minimumCost = dp{i][lastColor];
// if (minimumCost != -1)
// {
// return minimumCost;
// }
//
// minimumCost = INT_MAX;
//
// if(minimumCost)
// if (lastColor != 0)
// {
// minimumCost = min(r[i]+minCost(0, i + 1) , minimumCost);
// }
// if (lastColor != 1 )
// {
// minimumCost = min(g[i]+minCost(1, i + 1), minimumCost);
//
// }
// if (lastColor != 2)
// {
// minimumCost = min(b[i]+minCost(2, i + 1), minimumCost);
//
// }
// return minimumCost;
//
//}
// int dp[5][101];
// int minimumReset(int index, int parenttype)
//{
// if (index == n)
// {
// return 0;
// }
//
// int &r = dp[parenttype][index];
// if (r != -1)
// {
// return r;
// }
// r = 0;
//
//
// if (parenttype != 3 || elements[index] == 0)
// {
// r = max(minimumReset(index + 1, 3), r);
//
// }
//
//
// if ((elements[index] == 1 || elements[index] == 3) && parenttype != 1)
// r = max(minimumReset(index + 1, 1)+1, r);
//
// if ((elements[index] == 2 || elements[index] == 3 )&& parenttype != 2)
// r = max(minimumReset(index + 1, 2)+1, r);
//
// return r;
//
//}
//
int n;
int elements[100001];
long long dp[100001];
long long minCost(int index) {
if (index == n - 1) {
return 0;
}
if (dp[index] != -1) {
return dp[index];
}
long long r = LLONG_MAX;
if (index + 1 < n) {
r = min(minCost(index + 1) + abs(elements[index] - elements[index + 1]), r);
}
if (index + 2 < n) {
r = min(minCost(index + 2) + abs(elements[index] - elements[index + 2]), r);
}
dp[index] = r;
return r;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
elements[i] = a;
}
for (int i = 0; i < 100001; i++) {
dp[i] = -1;
}
cout << minCost(0);
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.narrow.change",
"literal.number.change",
"variable_declaration.array_dimensions.change",
"variable_declaration.value.change",
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 952,437 | 952,436 | u927144274 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
const int N = 100000;
int h[N], f[N];
int main() {
int n;
for (int i = 0; i < n; i++)
cin >> h[i];
f[0] = 0;
f[1] = abs(h[0] - h[1]);
for (int i = 2; i < n; i++) {
f[i] =
min(f[i - 1] + abs(h[i] - h[i - 1]), f[i - 2] + abs(h[i] - h[i - 2]));
}
cout << f[n - 1];
} | #include <bits/stdc++.h>
using namespace std;
const int N = 100000;
int h[N], f[N];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++)
cin >> h[i];
f[0] = 0;
f[1] = abs(h[0] - h[1]);
for (int i = 2; i < n; i++) {
f[i] =
min(f[i - 1] + abs(h[i] - h[i - 1]), f[i - 2] + abs(h[i] - h[i - 2]));
}
cout << f[n - 1];
} | [] | 952,448 | 952,449 | u943017136 | cpp |
p03160 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define pb push_back
#define P pair<int, int>
using namespace std;
using ll = long long;
// using mod = int 1000000000 + 7;
void self_max(int &a, int b) { a = max(a, b); }
void self_min(int &a, int b) { a = min(a, b); }
int main() {
int n;
cin >> n;
vector<int> dp(n, 0);
int arr[n];
rep(i, n) { cin >> arr[i]; }
dp[0] = arr[0];
dp[1] = abs(arr[1] - arr[0]);
for (int i = 2; i < n; i++) {
dp[i] = min(dp[i - 2] + abs(arr[i] - arr[i - 2]),
dp[i - 1] + abs(arr[i] - arr[i - 1]));
}
cout << dp[n - 1] << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define pb push_back
#define P pair<int, int>
using namespace std;
using ll = long long;
// using mod = int 1000000000 + 7;
void self_max(int &a, int b) { a = max(a, b); }
void self_min(int &a, int b) { a = min(a, b); }
int main() {
int n;
cin >> n;
vector<int> dp(n, 0);
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(dp[i - 2] + abs(arr[i] - arr[i - 2]),
dp[i - 1] + abs(arr[i] - arr[i - 1]));
}
cout << dp[n - 1] << endl;
return 0;
}
| [] | 952,453 | 952,454 | u366686355 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n] = {};
vector<int> dp(n, INT_MAX);
for (int i = 0; i < n; i++)
cin >> arr[i];
dp[0];
for (int i = 0; i < n; i++) {
for (int j : {i + 1, i + 2}) {
if (j < n) {
dp[j] = min(dp[j], dp[i] + abs(arr[j] - arr[i]));
}
}
}
cout << dp[n - 1] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n] = {};
vector<int> dp(n, INT_MAX);
for (int i = 0; i < n; i++)
cin >> arr[i];
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j : {i + 1, i + 2}) {
if (j < n) {
dp[j] = min(dp[j], dp[i] + abs(arr[j] - arr[i]));
}
}
}
cout << dp[n - 1] << endl;
return 0;
} | [
"assignment.change"
] | 952,455 | 952,456 | u366686355 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n] = {};
vector<int> dp(n, INT_MAX);
for (int i = 0; i < n; i++)
cin >> arr[i];
dp[0];
for (int i = 1; i < n; i++) {
for (int j : {i + 1, i + 2}) {
if (j < n) {
dp[j] = min(dp[j], dp[i] + abs(arr[j] - arr[i]));
}
}
}
cout << dp[n - 1] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n] = {};
vector<int> dp(n, INT_MAX);
for (int i = 0; i < n; i++)
cin >> arr[i];
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j : {i + 1, i + 2}) {
if (j < n) {
dp[j] = min(dp[j], dp[i] + abs(arr[j] - arr[i]));
}
}
}
cout << dp[n - 1] << endl;
return 0;
} | [
"assignment.change",
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 952,457 | 952,456 | u366686355 | cpp |
p03160 | #include <bits/stdc++.h>
#define ll long long
using namespace std;
int main() {
ll n;
cin >> n;
ll ar[n];
for (ll i = 0; i < n; ++i) {
cin >> ar[i];
}
ll dp[n + 1];
dp[0] = 0;
dp[1] = 0;
dp[2] = ar[1] - ar[0];
for (ll i = 3; i < n + 1; ++i) {
dp[i] = min(dp[i - 1] + abs(ar[i - 1] - ar[i - 2]),
dp[i - 2] + abs(ar[i - 1] - ar[i - 3]));
}
cout << dp[n];
}
| #include <bits/stdc++.h>
#define ll long long
using namespace std;
int main() {
ll n;
cin >> n;
ll ar[n];
for (ll i = 0; i < n; ++i) {
cin >> ar[i];
}
ll dp[n + 1];
dp[0] = 0;
dp[1] = 0;
dp[2] = abs(ar[1] - ar[0]);
for (ll i = 3; i < n + 1; ++i) {
dp[i] = min(dp[i - 1] + abs(ar[i - 1] - ar[i - 2]),
dp[i - 2] + abs(ar[i - 1] - ar[i - 3]));
}
cout << dp[n];
}
| [
"call.add",
"call.arguments.change"
] | 952,458 | 952,459 | u328627271 | cpp |
p03160 | /* "The world is full of obvious things which nobody by any chance ever
* observes." */
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define mod 1000000007
#define pi 3.14159265358979323846
#define pb push_back
#define mk make_pair
#define popcnt(a) \
_Generic((a), int \
: __builtin_popcount(a), \ long long \
: __builtin_popcountll(a))
#define precise(x) cout << fixed << setprecision(10) << x
#define test cout << "#";
#define input freopen("input.txt", "r", stdin)
#define output freopen("output.txt", "w", stdout)
const ll inf = 1e18L + 2;
ll ans[1000001];
ll solve(vector<ll> &v, ll n) {
if (n == 1)
return v[n - 1];
if (n == 2)
return abs(v[n - 1] - v[n - 2]);
if (ans[n] != -1)
return ans[n];
return ans[n] = min(solve(v, n - 1) + abs(v[n - 1] - v[n - 2]),
solve(v, n - 2) + abs(v[n - 1] - v[n - 3]));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll n;
cin >> n;
vector<ll> v(n);
memset(ans, -1, sizeof(ans));
for (ll x = 0; x < n; x++)
cin >> v[x];
cout << solve(v, n);
} | /* "The world is full of obvious things which nobody by any chance ever
* observes." */
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define mod 1000000007
#define pi 3.14159265358979323846
#define pb push_back
#define mk make_pair
#define popcnt(a) \
_Generic((a), int \
: __builtin_popcount(a), \ long long \
: __builtin_popcountll(a))
#define precise(x) cout << fixed << setprecision(10) << x
#define test cout << "#";
#define input freopen("input.txt", "r", stdin)
#define output freopen("output.txt", "w", stdout)
const ll inf = 1e18L + 2;
ll ans[1000001];
ll solve(vector<ll> &v, ll n) {
if (n == 1)
return 0;
if (n == 2)
return abs(v[n - 1] - v[n - 2]);
if (ans[n] != -1)
return ans[n];
return ans[n] = min(solve(v, n - 1) + abs(v[n - 1] - v[n - 2]),
solve(v, n - 2) + abs(v[n - 1] - v[n - 3]));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll n;
cin >> n;
vector<ll> v(n);
memset(ans, -1, sizeof(ans));
for (ll x = 0; x < n; x++)
cin >> v[x];
cout << solve(v, n);
} | [
"identifier.replace.remove",
"literal.replace.add",
"function.return_value.change"
] | 952,462 | 952,463 | u466535000 | cpp |
p03160 | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (long long i = 0; i < (long long)(n); i++)
#define REP(i, k, n) for (long long i = k; i < (long long)(n); i++)
#define all(a) a.begin(), a.end()
#define eb emplace_back
#define pb push_back
#define lb(v, k) lower_bound(all(v), k) - v.begin()
#define chmin(x, y) \
if (x > y) \
x = y
#define chmax(x, y) \
if (x < y) \
x = y
typedef long long ll;
typedef pair<ll, ll> P;
typedef tuple<ll, ll, ll> PP;
typedef priority_queue<ll> PQ;
typedef priority_queue<ll, vector<ll>, greater<ll>> SPQ;
using vi = vector<ll>;
using vvi = vector<vector<ll>>;
using vc = vector<char>;
using vvc = vector<vector<char>>;
ll inf = 100100100100;
const int mod = 1000000007;
int main() {
int n;
cin >> n;
vi v(n);
rep(i, n) cin >> v[i];
vi dp(n);
dp[0] = 0;
dp[1] = abs(v[1] - v[0]);
REP(i, 2, n) {
dp[i] = min(dp[i - 1] + abs(v[i] - v[i - 1]), dp[i - 2] + v[i] - v[i - 2]);
}
cout << dp[n - 1] << endl;
} | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (long long i = 0; i < (long long)(n); i++)
#define REP(i, k, n) for (long long i = k; i < (long long)(n); i++)
#define all(a) a.begin(), a.end()
#define eb emplace_back
#define pb push_back
#define lb(v, k) lower_bound(all(v), k) - v.begin()
#define chmin(x, y) \
if (x > y) \
x = y
#define chmax(x, y) \
if (x < y) \
x = y
typedef long long ll;
typedef pair<ll, ll> P;
typedef tuple<ll, ll, ll> PP;
typedef priority_queue<ll> PQ;
typedef priority_queue<ll, vector<ll>, greater<ll>> SPQ;
using vi = vector<ll>;
using vvi = vector<vector<ll>>;
using vc = vector<char>;
using vvc = vector<vector<char>>;
ll inf = 100100100100;
const int mod = 1000000007;
int main() {
int n;
cin >> n;
vi v(n);
rep(i, n) cin >> v[i];
vi dp(n);
dp[0] = 0;
dp[1] = abs(v[1] - v[0]);
REP(i, 2, n) {
dp[i] =
min(dp[i - 1] + abs(v[i] - v[i - 1]), dp[i - 2] + abs(v[i] - v[i - 2]));
}
cout << dp[n - 1] << endl;
} | [
"call.add",
"call.arguments.change"
] | 952,464 | 952,465 | u422633119 | cpp |
p03160 | #include <bits/stdc++.h>
#define ll long long int
using namespace std;
int main() {
ll n, a[200005];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
ll dp[200005];
dp[0] = a[0];
dp[1] = abs(a[1] - a[0]);
ll ans = INT_MAX;
for (int i = 2; i < n; i++) {
ll v1 = dp[i - 1] + abs(a[i] - a[i - 1]);
ll v2 = dp[i - 2] + abs(a[i] - a[i - 2]);
dp[i] = min(v1, v2);
}
cout << dp[n - 1] << "\n";
return 0;
} | #include <bits/stdc++.h>
#define ll long long int
using namespace std;
int main() {
ll n, a[200005];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
ll dp[200005];
dp[0] = 0;
dp[1] = abs(a[1] - a[0]);
ll ans = INT_MAX;
for (int i = 2; i < n; i++) {
ll v1 = dp[i - 1] + abs(a[i] - a[i - 1]);
ll v2 = dp[i - 2] + abs(a[i] - a[i - 2]);
dp[i] = min(v1, v2);
}
cout << dp[n - 1] << "\n";
return 0;
} | [] | 952,468 | 952,469 | u295716434 | cpp |
p03160 | // In the Name of God
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> h(n);
for (int i = 0; i < n; i++)
cin >> h[i];
vector<int> dp(n);
dp[0] = h[0];
dp[1] = abs(h[0] - 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 - 1] << endl;
return 0;
} | // In the Name of God
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> h(n);
for (int i = 0; i < n; i++)
cin >> h[i];
vector<int> dp(n);
dp[0] = 0;
dp[1] = abs(h[0] - 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 - 1] << endl;
return 0;
} | [] | 952,482 | 952,483 | u566183836 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.