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;
int main() {
int n;
cin >> n;
int h[n];
for (int i = 0; i < n; i++) {
cin >> h[i];
}
int c[n] = {0};
c[1] = h[1] - h[0];
for (int i = 2; i < n; i++) {
c[i] =
min(c[i - 1] + abs(h[i] - h[i - 1]), c[i - 2] + abs(h[i] - h[i - 2]));
}
cout << c[n - 1] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int h[n];
for (int i = 0; i < n; i++) {
cin >> h[i];
}
int c[n] = {0};
c[1] = abs(h[1] - h[0]);
for (int i = 2; i < n; i++) {
c[i] =
min(c[i - 1] + abs(h[i] - h[i - 1]), c[i - 2] + abs(h[i] - h[i - 2]));
}
cout << c[n - 1] << endl;
return 0;
} | [
"call.add",
"call.arguments.change"
] | 955,213 | 955,214 | u107193447 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int n;
int a[1000009], dp[1000009];
int main() {
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i];
dp[0] = 0;
dp[1] = abs(a[1] - a[0]);
for (int i = 1; i < n; i++) {
dp[i] =
min(dp[i - 2] + abs(a[i] - a[i - 2]), dp[i - 1] + abs(a[i] - a[i - 1]));
}
cout << dp[n - 1];
}
| #include <bits/stdc++.h>
using namespace std;
int n;
int a[1000009], dp[1000009];
int main() {
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i];
dp[0] = 0;
dp[1] = abs(a[1] - a[0]);
for (int i = 2; i < n; i++) {
dp[i] =
min(dp[i - 2] + abs(a[i] - a[i - 2]), dp[i - 1] + abs(a[i] - a[i - 1]));
}
cout << dp[n - 1];
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 955,217 | 955,218 | u096956975 | cpp |
p03160 | /////////////////////////////////////////////////////////////////////////////////
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$' `$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$//
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$' `$$$$$$$$$$$$$$$$$$$$$$$$$$$$//
//$$$'`$$$$$$$$$$$$$'`$$$$$$! !$$$$$$'`$$$$$$$$$$$$$'`$$$//
//$$$$ $$$$$$$$$$$ $$$$$$$ $$$$$$$ $$$$$$$$$$$ $$$$//
//$$$$. `$' \' \$` $$$$$$$! $$ $$ !$$$$$$$ '$/ `/ `$'
//.$$$$//
//$$$$$. !\ i i .$$$$$$$$ $$$$ $$$$ $$$$$$$$. i i /!
//.$$$$$//
//$$$$$$ `--`--.$$$$$$$$$ $$ $$ $$$$$$$$$.--'--' $$$$$$//
//$$$$$$L `$$$$$^^$$ $$^^$$$$$' J$$$$$$//
//$$$$$$$. .' ""~ $$$ $. .$ $$$ ~"" `. .$$$$$$$//
//$$$$$$$$. ; .e$$$$$! $$. .$$ !$$$$$e, ; .$$$$$$$$//
//$$$$$$$$$ `.$$$$$$$$$$$$ $$$. .$$$ $$$$$$$$$$$$.' $$$$$$$$$//
//$$$$$$$$ .$$$$$$$$$$$$$! $$`$$$$$$$$'$$ !$$$$$$$$$$$$$. $$$$$$$$//
//$$$$$$$ $$$$$$$$$$$$$$$$. $ $$ $ .$$$$$$$$$$$$$$$$ $$$$$$$//
// $ $$ $
// //
// $. $$ .$
// //
// `$ $'
// //
// `$$$$$$$$'
// //
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
#include <bits/stdc++.h>
using namespace std;
// Type-Define
typedef long long ll;
typedef std::vector<int> vi;
typedef std::vector<std::string> vs;
typedef std::vector<char> vc;
typedef std::vector<vector<int>> vii;
typedef std::pair<int, int> pii;
// Hash-Define
#define int long long
#define MOD 1000000007
#define debugStart cerr << "\n[DEBUG START]\n"
#define debugStop cerr << "\n[DEBUG STOP]\n"
#define KHATAM cout << std::endl;
#define set_zero(x) memset(x, 0, sizeof(x));
#define ForPrint(x) \
std::for_each(begin(x), end(x), \
[](auto const &el) { std::cout << el << " "; })
// Functions
template <typename T> auto gcd(T a, T b) -> int {
return (b == 0) ? a : gcd(b, a % b);
}
const int inf = 1e9 + 5;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
int T = 1;
// cin >> T;
for (int testcase = 1; testcase <= T; ++testcase) {
int N;
std::cin >> N;
int arr[N];
int a, b, c = 0;
for (int i = 0; i < N; ++i) {
std::cin >> arr[i];
if (i == 0) {
a = arr[i];
} else if (i == 1)
c = b = abs(arr[i] - arr[i - 1]);
else {
c = min(abs(arr[i] - arr[i - 1]) + b, abs(arr[i] - arr[i - 2]) + a);
a = b;
b = c;
}
}
std::cout << c;
KHATAM;
}
return 0;
}
| /////////////////////////////////////////////////////////////////////////////////
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$' `$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$//
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$' `$$$$$$$$$$$$$$$$$$$$$$$$$$$$//
//$$$'`$$$$$$$$$$$$$'`$$$$$$! !$$$$$$'`$$$$$$$$$$$$$'`$$$//
//$$$$ $$$$$$$$$$$ $$$$$$$ $$$$$$$ $$$$$$$$$$$ $$$$//
//$$$$. `$' \' \$` $$$$$$$! $$ $$ !$$$$$$$ '$/ `/ `$'
//.$$$$//
//$$$$$. !\ i i .$$$$$$$$ $$$$ $$$$ $$$$$$$$. i i /!
//.$$$$$//
//$$$$$$ `--`--.$$$$$$$$$ $$ $$ $$$$$$$$$.--'--' $$$$$$//
//$$$$$$L `$$$$$^^$$ $$^^$$$$$' J$$$$$$//
//$$$$$$$. .' ""~ $$$ $. .$ $$$ ~"" `. .$$$$$$$//
//$$$$$$$$. ; .e$$$$$! $$. .$$ !$$$$$e, ; .$$$$$$$$//
//$$$$$$$$$ `.$$$$$$$$$$$$ $$$. .$$$ $$$$$$$$$$$$.' $$$$$$$$$//
//$$$$$$$$ .$$$$$$$$$$$$$! $$`$$$$$$$$'$$ !$$$$$$$$$$$$$. $$$$$$$$//
//$$$$$$$ $$$$$$$$$$$$$$$$. $ $$ $ .$$$$$$$$$$$$$$$$ $$$$$$$//
// $ $$ $
// //
// $. $$ .$
// //
// `$ $'
// //
// `$$$$$$$$'
// //
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
#include <bits/stdc++.h>
using namespace std;
// Type-Define
typedef long long ll;
typedef std::vector<int> vi;
typedef std::vector<std::string> vs;
typedef std::vector<char> vc;
typedef std::vector<vector<int>> vii;
typedef std::pair<int, int> pii;
// Hash-Define
#define int long long
#define MOD 1000000007
#define debugStart cerr << "\n[DEBUG START]\n"
#define debugStop cerr << "\n[DEBUG STOP]\n"
#define KHATAM cout << std::endl;
#define set_zero(x) memset(x, 0, sizeof(x));
#define ForPrint(x) \
std::for_each(begin(x), end(x), \
[](auto const &el) { std::cout << el << " "; })
// Functions
template <typename T> auto gcd(T a, T b) -> int {
return (b == 0) ? a : gcd(b, a % b);
}
const int inf = 1e9 + 5;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
int T = 1;
// cin >> T;
for (int testcase = 1; testcase <= T; ++testcase) {
int N;
std::cin >> N;
int arr[N];
int a, b, c = 0;
for (int i = 0; i < N; ++i) {
std::cin >> arr[i];
if (i == 0) {
c = a = 0;
} else if (i == 1)
c = b = abs(arr[i] - arr[i - 1]);
else {
c = min(abs(arr[i] - arr[i - 1]) + b, abs(arr[i] - arr[i - 2]) + a);
a = b;
b = c;
}
}
std::cout << c;
KHATAM;
}
return 0;
}
| [
"assignment.change",
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add"
] | 955,222 | 955,223 | u758887062 | cpp |
p03160 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
const int INF = 1e5 + 9;
int main() {
int n;
scanf("%d", &n);
vector<int> v(n);
for (int &x : v)
scanf("%d", &x);
vector<int> dp(n, INF);
dp[0] = 0;
for (int i = 0; i < n; ++i) {
for (int j : {i + 1, i + 2}) {
if (j < n)
dp[j] = min(dp[j], dp[i] + abs(v[i] - v[j]));
}
}
printf("%d\n", dp[n - 1]);
return 0;
} | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
const int INF = 1e9 + 5;
int main() {
int n;
scanf("%d", &n);
vector<int> v(n);
for (int &x : v)
scanf("%d", &x);
vector<int> dp(n, INF);
dp[0] = 0;
for (int i = 0; i < n; ++i) {
for (int j : {i + 1, i + 2}) {
if (j < n)
dp[j] = min(dp[j], dp[i] + abs(v[i] - v[j]));
}
}
printf("%d\n", dp[n - 1]);
return 0;
} | [
"literal.number.change",
"expression.operation.binary.change"
] | 955,224 | 955,225 | u753187241 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> VL;
typedef vector<pair<ll, ll>> VPI;
typedef pair<ll, ll> PLL;
typedef map<ll, ll> MLL;
#define EPS 1e-9
#define pb push_back
#define FOR(i, a, b) for (ll i = a; i < b; i++)
#define PI 3.1415926535897932384626433832795
#define MOD 1000000007
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n;
cin >> n;
VL h(n + 1);
FOR(i, 1, n + 1) { cin >> h[i]; }
VL dp(n + 1, -1);
dp[1] = 0;
dp[2] = h[2] - h[1];
FOR(i, 3, n + 1) {
dp[i] =
min(dp[i - 1] + abs(h[i] - h[i - 1]), dp[i - 2] + abs(h[i] - h[i - 2]));
}
cout << dp[n] << "\n";
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> VL;
typedef vector<pair<ll, ll>> VPI;
typedef pair<ll, ll> PLL;
typedef map<ll, ll> MLL;
#define EPS 1e-9
#define pb push_back
#define FOR(i, a, b) for (ll i = a; i < b; i++)
#define PI 3.1415926535897932384626433832795
#define MOD 1000000007
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n;
cin >> n;
VL h(n + 1);
FOR(i, 1, n + 1) { cin >> h[i]; }
VL dp(n + 1, -1);
dp[1] = 0;
dp[2] = abs(h[2] - h[1]);
FOR(i, 3, n + 1) {
dp[i] =
min(dp[i - 1] + abs(h[i] - h[i - 1]), dp[i - 2] + abs(h[i] - h[i - 2]));
}
cout << dp[n] << "\n";
return 0;
}
| [
"call.add",
"call.arguments.change"
] | 955,226 | 955,227 | u019415633 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int h[n + 2000];
long long cs[n + 20];
for (int i = 1; i <= n; i++)
cin >> h[i];
cs[0] = 0;
cs[1] = 0;
cs[2] = abs(h[2] - h[1]);
for (int i = 3; i <= n; i++)
cs[i] =
min(cs[i - 2] + abs(h[i] - h[i - 2]), cs[i - 1] + abs(h[i] - h[i - 2]));
cout << cs[n];
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int h[n + 2000];
long long cs[n + 20];
for (int i = 1; i <= n; i++)
cin >> h[i];
cs[0] = 0;
cs[1] = 0;
cs[2] = abs(h[2] - h[1]);
for (int i = 3; i <= n; i++)
cs[i] =
min(cs[i - 2] + abs(h[i] - h[i - 2]), cs[i - 1] + abs(h[i] - h[i - 1]));
cout << cs[n];
return 0;
} | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 955,230 | 955,231 | u383252618 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int jp[n + 1], h[n + 1];
for (int i = 1; i <= n; i++) {
cin >> h[i];
}
h[0] = 0;
jp[0] = 0;
jp[1] = 0;
for (int i = 2; i <= n; i++) {
jp[i] = min((abs(h[i] - h[i - 1]) + jp[i - 1]),
(abs(h[i] - h[i - 2]) + jp[i - 2]));
}
cout << jp[n];
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int jp[n + 1], h[n + 1];
for (int i = 1; i <= n; i++) {
cin >> h[i];
}
h[0] = 10000000;
jp[0] = 0;
jp[1] = 0;
for (int i = 2; i <= n; i++) {
jp[i] = min((abs(h[i] - h[i - 1]) + jp[i - 1]),
(abs(h[i] - h[i - 2]) + jp[i - 2]));
}
cout << jp[n];
} | [
"literal.number.change",
"assignment.value.change"
] | 955,237 | 955,238 | u403935967 | cpp |
p03160 | #include <bits/stdc++.h>
#define rep(i, a, b) for (int i = a; i < b; i++)
using namespace std;
typedef long long ll;
const int inf = INT_MAX / 2;
const ll infl = 1LL << 60;
const ll mod = 1e9 + 7;
template <typename T> ostream &operator<<(ostream &os, vector<T> v) {
for (auto &i : v)
os << i << " ";
return os;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &i : v)
is >> i;
return is;
}
template <typename K, typename V>
ostream &operator<<(ostream &os, unordered_map<K, V> m) {
for (auto &i : m)
os << i.first << ":" << i.second << endl;
return os;
}
template <typename T> inline bool chmin(T &x, T y) {
if (x > y) {
x = y;
return true;
}
return false;
}
template <typename T> inline bool chmax(T &x, T y) {
if (x < y) {
x = y;
return true;
}
return false;
}
int N;
int H[100010];
int dp[100010];
int main() {
cin >> N;
rep(i, 0, N) cin >> H[i];
rep(i, 0, N) H[i] = inf;
dp[0] = 0;
rep(i, 0, N) {
chmin(dp[i + 1], dp[i] + abs(H[i] - H[i + 1]));
chmin(dp[i + 2], dp[i] + abs(H[i] - H[i + 2]));
}
cout << dp[N - 1] << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, a, b) for (int i = a; i < b; i++)
using namespace std;
typedef long long ll;
const int inf = INT_MAX / 2;
const ll infl = 1LL << 60;
const ll mod = 1e9 + 7;
template <typename T> ostream &operator<<(ostream &os, vector<T> v) {
for (auto &i : v)
os << i << " ";
return os;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &i : v)
is >> i;
return is;
}
template <typename K, typename V>
ostream &operator<<(ostream &os, unordered_map<K, V> m) {
for (auto &i : m)
os << i.first << ":" << i.second << endl;
return os;
}
template <typename T> inline bool chmin(T &x, T y) {
if (x > y) {
x = y;
return true;
}
return false;
}
template <typename T> inline bool chmax(T &x, T y) {
if (x < y) {
x = y;
return true;
}
return false;
}
int N;
int H[100010];
int dp[100010];
int main() {
cin >> N;
rep(i, 0, N) cin >> H[i];
rep(i, 0, N) dp[i] = inf;
dp[0] = 0;
rep(i, 0, N) {
chmin(dp[i + 1], dp[i] + abs(H[i] - H[i + 1]));
chmin(dp[i + 2], dp[i] + abs(H[i] - H[i + 2]));
}
cout << dp[N - 1] << endl;
return 0;
}
| [
"assignment.variable.change",
"identifier.change"
] | 955,239 | 955,240 | u171804186 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const int N = 2e5 + 5;
ll dp[N];
ll a[N];
ll solve(int i) {
if (i <= 1)
return 0;
else if (dp[i] != -1)
return dp[i];
return dp[i] = min(abs(a[i] - a[i - 2]) + solve(i - 2),
abs(a[i] - a[i - 1]) + solve(i - 1));
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i], dp[i] = -1;
dp[0] = INT_MAX;
cout << solve(n) << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const int N = 2e5 + 5;
ll dp[N];
ll a[N];
ll solve(int i) {
if (i <= 1)
return 0;
else if (dp[i] != -1)
return dp[i];
return dp[i] = min(abs(a[i] - a[i - 2]) + solve(i - 2),
abs(a[i] - a[i - 1]) + solve(i - 1));
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i], dp[i] = -1;
a[0] = INT_MAX;
cout << solve(n) << endl;
} | [
"assignment.variable.change",
"identifier.change"
] | 955,241 | 955,242 | u109008163 | cpp |
p03160 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define ll long long
#define ull unsigned long long
#define l long
#define xx 1000000007
#define max 1000
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
int a[n];
for (int i = 1; i <= n; i++)
cin >> a[i];
// for(int i=1;i<=n;i++)cout<<a[i]<<" ";
int sum[n];
sum[1] = 0;
sum[2] = abs(a[2] - a[1]);
sum[3] = min((sum[1] + abs(a[3] - a[2])), abs(a[3] - a[1]));
for (int i = 4; i <= n; i++) {
int x = sum[i - 2] + abs(a[i] - a[i - 2]),
y = sum[i - 1] + abs(a[i] - a[i - 1]);
sum[i] = min(x, y);
// cout<<sum[i]<<" ";
}
cout << sum[n];
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define ll long long
#define ull unsigned long long
#define l long
#define xx 1000000007
#define max 1000
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
int a[n];
for (int i = 1; i <= n; i++)
cin >> a[i];
// for(int i=1;i<=n;i++)cout<<a[i]<<" ";
int sum[n];
sum[1] = 0;
sum[2] = abs(a[2] - a[1]);
sum[3] = min((sum[2] + abs(a[3] - a[2])), abs(a[3] - a[1]));
// cout<<sum[2]<<" "<<sum[3]<<" ";
for (int i = 4; i <= n; i++) {
int x = sum[i - 2] + abs(a[i] - a[i - 2]),
y = sum[i - 1] + abs(a[i] - a[i - 1]);
sum[i] = min(x, y);
// cout<<sum[i]<<" ";
}
cout << sum[n];
}
| [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 955,249 | 955,250 | u253526353 | cpp |
p03160 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define ll long long
#define ull unsigned long long
#define l long
#define xx 1000000007
#define max 1000
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
int a[n];
for (int i = 1; i <= n; i++)
cin >> a[i];
int sum[n];
sum[1] = 1;
sum[2] = abs(a[2] - a[1]);
sum[3] = min((sum[1] + abs(a[3] - a[2])), abs(a[3] - a[1]));
for (int i = 4; i <= n; i++) {
int x = sum[i - 2] + abs(a[i] - a[i - 2]),
y = sum[i - 1] + abs(a[i] - a[i - 1]);
sum[i] = min(x, y);
// cout<<sum[i]<<" ";
}
cout << sum[n];
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define ll long long
#define ull unsigned long long
#define l long
#define xx 1000000007
#define max 1000
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
int a[n];
for (int i = 1; i <= n; i++)
cin >> a[i];
// for(int i=1;i<=n;i++)cout<<a[i]<<" ";
int sum[n];
sum[1] = 0;
sum[2] = abs(a[2] - a[1]);
sum[3] = min((sum[2] + abs(a[3] - a[2])), abs(a[3] - a[1]));
// cout<<sum[2]<<" "<<sum[3]<<" ";
for (int i = 4; i <= n; i++) {
int x = sum[i - 2] + abs(a[i] - a[i - 2]),
y = sum[i - 1] + abs(a[i] - a[i - 1]);
sum[i] = min(x, y);
// cout<<sum[i]<<" ";
}
cout << sum[n];
}
| [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 955,251 | 955,250 | u253526353 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const long long INF = 1LL < 60;
int main() {
int N;
cin >> N;
vector<long long int> h(N);
for (int i = 0; i < N; i++) {
cin >> h[i];
}
long long dp[100010];
// 初期化（最小化問題なのでINFに初期化）
for (int i = 0; i < N; i++) {
dp[i] = INF;
}
// 初期条件
dp[0] = 0;
for (int i = 0; i < N; i++) {
chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
if (i > 1)
chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
cout << dp[N - 1] << endl;
}
| #include <bits/stdc++.h>
using namespace std;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const long long INF = 1LL << 60;
int main() {
int N;
cin >> N;
vector<long long int> h(N);
for (int i = 0; i < N; i++) {
cin >> h[i];
}
long long dp[100010];
// 初期化（最小化問題なのでINFに初期化）
for (int i = 0; i < 100010; i++) {
dp[i] = INF;
}
// 初期条件
dp[0] = 0;
for (int i = 0; i < N; i++) {
chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
if (i > 1)
chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
cout << dp[N - 1] << endl;
}
| [
"expression.operation.binary.change",
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change"
] | 955,260 | 955,261 | u665871498 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int dp[n];
dp[0] = 0;
dp[1] = arr[1] - arr[0];
for (int i = 2; i < n; i++) {
int a = dp[i - 1] + abs(arr[i] - arr[i - 1]);
int b = dp[i - 2] + abs(arr[i] - arr[i - 2]);
dp[i] = min(a, b);
}
cout << dp[n - 1];
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int dp[n];
dp[0] = 0;
dp[1] = abs(arr[1] - arr[0]);
for (int i = 2; i < n; i++) {
int a = dp[i - 1] + abs(arr[i] - arr[i - 1]);
int b = dp[i - 2] + abs(arr[i] - arr[i - 2]);
dp[i] = min(a, b);
}
cout << dp[n - 1];
}
| [
"call.add",
"call.arguments.change"
] | 955,262 | 955,263 | u801786962 | cpp |
p03160 | #include <bits/stdc++.h>
#define ll long long
#define all(v) v.begin(), v.end()
#define pb push_back
#define f first
#define s second
#define mp make_pair
#define tr(con) for (auto it = con.begin(); it != con.end(); it++)
#define INF 1e9 + 7 // 1 * 10^9+ 7
#define rep(i, l, r) for (ll i = l; i <= r; i++)
#define fo(i, n) for (ll i = 0; i < n; i++)
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n;
cin >> n;
ll h[n + 1];
h[0] = 0;
rep(i, 1, n) cin >> h[i];
ll val[n + 1];
val[0] = 0;
val[1] = 0;
val[2] = h[2] - h[1];
rep(i, 3, n) {
val[i] = min(val[i - 2] + abs(h[i] - h[i - 2]),
val[i - 1] + abs(h[i] - h[i - 1]));
}
cout << val[n];
return 0;
}
| #include <bits/stdc++.h>
#define ll long long
#define all(v) v.begin(), v.end()
#define pb push_back
#define f first
#define s second
#define mp make_pair
#define tr(con) for (auto it = con.begin(); it != con.end(); it++)
#define INF 1e9 + 7 // 1 * 10^9+ 7
#define rep(i, l, r) for (ll i = l; i <= r; i++)
#define fo(i, n) for (ll i = 0; i < n; i++)
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n;
cin >> n;
ll h[n + 1];
h[0] = 0;
rep(i, 1, n) cin >> h[i];
ll val[n + 1];
val[0] = 0;
val[1] = 0;
val[2] = abs(h[2] - h[1]);
rep(i, 3, n) {
val[i] = min(val[i - 2] + abs(h[i] - h[i - 2]),
val[i - 1] + abs(h[i] - h[i - 1]));
}
cout << val[n];
return 0;
}
| [
"call.add",
"call.arguments.change"
] | 955,264 | 955,265 | u243556669 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define MAX_N 100000
int dp[MAX_N];
int main() {
int n;
cin >> n;
int step[n];
for (int i = 0; i < n; i++) {
cin >> step[i];
}
dp[0] = 0;
dp[1] = dp[0] + abs(step[1] - step[0]);
for (int i = 2; i < n; i++) {
dp[i] = min(dp[i - 1] + abs(step[i] - step[i + 1]),
dp[i - 2] + abs(step[i] - step[i + 2]));
}
cout << dp[n - 1] << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define MAX_N 100000
int long dp[MAX_N];
int main() {
int n;
cin >> n;
int step[n];
for (int i = 0; i < n; i++) {
cin >> step[i];
}
dp[0] = 0;
dp[1] = dp[0] + abs(step[1] - step[0]);
for (int i = 2; i < n; i++) {
dp[i] = min(dp[i - 1] + abs(step[i] - step[i - 1]),
dp[i - 2] + abs(step[i] - step[i - 2]));
}
cout << dp[n - 1] << endl;
} | [
"variable_declaration.array_dimensions.change",
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 955,269 | 955,270 | u158628538 | cpp |
p03160 | #include <climits>
#include <iostream>
using namespace std;
long long int arr[100001];
long long int store[100001];
long long int find(long long int n, long long int k) {
if (store[n] != -1) {
return store[n];
} else {
long long int min1 = INT_MAX, cost = 0, i;
for (i = 1; n - i >= 0 && i <= k; ++i) {
cost = abs(arr[n] - arr[n - i]) + find(n - i, k);
if (cost < min1) {
min1 = cost;
}
}
store[n] = min1;
return store[n];
}
}
int main() {
long long int n, i;
cin >> n;
for (i = 1; i <= n; ++i) {
cin >> arr[i];
}
store[1] = 0;
for (i = 3; i < 100001; ++i) {
store[i] = -1;
}
cout << find(n, 2) << endl;
return 0;
} | #include <climits>
#include <iostream>
using namespace std;
long long int arr[100001];
long long int store[100001];
long long int find(long long int n, long long int k) {
if (store[n] != -1) {
return store[n];
} else {
long long int min1 = INT_MAX, cost = 0, i;
for (i = 1; n - i > 0 && i <= k; ++i) {
cost = abs(arr[n] - arr[n - i]) + find(n - i, k);
if (cost < min1) {
min1 = cost;
}
}
store[n] = min1;
return store[n];
}
}
int main() {
long long int n, i;
cin >> n;
for (i = 1; i <= n; ++i) {
cin >> arr[i];
}
store[1] = 0;
for (i = 2; i < 100001; ++i) {
store[i] = -1;
}
cout << find(n, 2) << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"literal.number.change",
"assignment.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 955,273 | 955,272 | u133712390 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int h[N];
for (int i = 0; i < N; i++) {
cin >> h[i];
}
int *table = new int[N];
table[0] = 0;
table[1] = abs(h[0] - h[1]);
table[2] = min(table[0] + abs(h[1] - h[2]), abs(h[0] - h[2]));
for (int i = 3; i < N; i++) {
table[i] = min(table[i - 1] + abs(h[i - 1] - h[i]),
table[i - 2] + abs(h[i - 2] - h[i]));
}
cout << table[N - 1] << "\n";
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int h[N];
for (int i = 0; i < N; i++) {
cin >> h[i];
}
int *table = new int[N];
table[0] = 0;
table[1] = abs(h[0] - h[1]);
table[2] = min(table[1] + abs(h[1] - h[2]), abs(h[0] - h[2]));
for (int i = 3; i < N; i++) {
table[i] = min(table[i - 1] + abs(h[i - 1] - h[i]),
table[i - 2] + abs(h[i - 2] - h[i]));
}
cout << table[N - 1] << "\n";
return 0;
}
| [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 955,274 | 955,275 | u995090660 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define pb push_back
#define S second
#define F first
#define f(i, n) for (int i = 0; i < n; i++)
#define fast \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define vi vector<int>
#define pii pair<int, int>
const int N = 1e5 + 10;
const int inf = 1e10;
int dp[N], a[N], n;
void solve() {
cin >> n;
f(i, n) cin >> a[i];
dp[0] = dp[1] = 0;
for (int i = 2; i <= n; i++) {
dp[i] = inf;
dp[i] = min(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];
}
signed main() {
fast;
int t = 1;
// cin >> t;
while (t--)
solve();
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define pb push_back
#define S second
#define F first
#define f(i, n) for (int i = 0; i < n; i++)
#define fast \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define vi vector<int>
#define pii pair<int, int>
const int N = 1e5 + 10;
const int inf = 1e10;
int dp[N], a[N], n;
void solve() {
cin >> n;
f(i, n) cin >> a[i + 1];
dp[0] = dp[1] = 0;
for (int i = 2; i <= n; i++) {
dp[i] = inf;
dp[i] = min(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];
}
signed main() {
fast;
int t = 1;
// cin >> t;
while (t--)
solve();
} | [
"expression.operation.binary.add"
] | 955,284 | 955,285 | u680493942 | cpp |
p03160 | #include <iostream>
using namespace std;
const int INF = 1e9;
int abs(int n) {
if (n >= 0)
return n;
else
return -n;
}
int min(int a, int b) {
if (a <= b)
return a;
else
return b;
}
main() {
int N;
cin >> N;
int h[N];
for (int ii = 0; ii < N; ii++) {
cin >> h[ii];
}
int dp[N]; //初期化
for (int ii = 0; ii < N; ii++) {
dp[ii] = INF;
}
dp[0] = 0;
for (int ii = 0; ii < N - 2; ii++) {
dp[ii + 1] = min(dp[ii + 1], dp[ii] + abs(h[ii + 1] - h[ii]));
dp[ii + 2] = min(dp[ii + 2], dp[ii] + abs(h[ii + 2] - h[ii]));
/* for(int ii=0;ii<N;ii++){
cout << dp[ii] << endl;
}
cout << endl;*/
}
int ii = N - 1;
dp[ii + 1] = min(dp[ii + 1], dp[ii] + abs(h[ii + 1] - h[ii]));
/* for(int ii=0;ii<N-1;ii++){
dp[ii+1]=min(dp[ii+1],dp[ii]+abs(h[ii+1]-h[ii]));
}*/
cout << dp[N - 1] << endl;
}
| #include <iostream>
using namespace std;
const int INF = 1e9;
int abs(int n) {
if (n >= 0)
return n;
else
return -n;
}
int min(int a, int b) {
if (a <= b)
return a;
else
return b;
}
main() {
int N;
cin >> N;
int h[N];
for (int ii = 0; ii < N; ii++) {
cin >> h[ii];
}
int dp[N]; //初期化
for (int ii = 0; ii < N; ii++) {
dp[ii] = INF;
}
dp[0] = 0;
for (int ii = 0; ii < N - 2; ii++) {
dp[ii + 1] = min(dp[ii + 1], dp[ii] + abs(h[ii + 1] - h[ii]));
dp[ii + 2] = min(dp[ii + 2], dp[ii] + abs(h[ii + 2] - h[ii]));
/* for(int ii=0;ii<N;ii++){
cout << dp[ii] << endl;
}
cout << endl;*/
}
int ii = N - 2;
dp[ii + 1] = min(dp[ii + 1], dp[ii] + abs(h[ii + 1] - h[ii]));
/* for(int ii=0;ii<N-1;ii++){
dp[ii+1]=min(dp[ii+1],dp[ii]+abs(h[ii+1]-h[ii]));
}*/
cout << dp[N - 1] << endl;
}
| [
"literal.number.change",
"expression.operation.binary.change"
] | 955,286 | 955,287 | u346834985 | cpp |
p03160 | #include <algorithm>
#include <cmath>
#include <cstdio>
using namespace std;
typedef long long ll;
int main() {
int n;
ll h[100000], dp[100010];
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d", &h[i]);
for (int i = 0; i < n; i++)
dp[i] = 200000;
dp[0] = 0;
dp[1] = abs(h[0] - h[1]);
for (int i = 2; i < n; i++) {
dp[i] = min(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
dp[i] = min(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
printf("%d", dp[n - 1]);
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
using namespace std;
typedef long long ll;
int main() {
int n, h[100000];
ll dp[100010];
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d", &h[i]);
for (int i = 0; i < n; i++)
dp[i] = 2000000000;
dp[0] = 0;
dp[1] = abs(h[0] - h[1]);
for (int i = 2; i < n; i++) {
dp[i] = min(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
dp[i] = min(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
printf("%d", dp[n - 1]);
return 0;
} | [
"literal.number.change",
"assignment.value.change"
] | 955,288 | 955,289 | u673980701 | cpp |
p03160 | #include <algorithm>
#include <cmath>
#include <cstdio>
using namespace std;
typedef long long ll;
int main() {
int n;
ll h[100000], dp[100010];
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d", &h[i]);
for (int i = 0; i < 100010; i++)
dp[i] = 100000;
dp[0] = 0;
dp[1] = abs(h[0] - h[1]);
for (int i = 2; i < n; i++) {
dp[i] = min(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
dp[i] = min(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
printf("%d", dp[n - 1]);
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
using namespace std;
typedef long long ll;
int main() {
int n, h[100000];
ll dp[100010];
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d", &h[i]);
for (int i = 0; i < n; i++)
dp[i] = 2000000000;
dp[0] = 0;
dp[1] = abs(h[0] - h[1]);
for (int i = 2; i < n; i++) {
dp[i] = min(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
dp[i] = min(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
printf("%d", dp[n - 1]);
return 0;
} | [
"identifier.replace.add",
"literal.replace.remove",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"literal.number.change",
"assignment.value.change"
] | 955,290 | 955,289 | u673980701 | cpp |
p03160 | #include <algorithm>
#include <cmath>
#include <cstdio>
using namespace std;
typedef long long ll;
int main() {
int n;
ll h[100010], dp[100010];
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d", &h[i]);
for (int i = 0; i < n; i++)
dp[i] = 100000;
dp[0] = 0;
dp[1] = abs(h[0] - h[1]);
for (int i = 2; i < n; i++) {
dp[i] = min(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
dp[i] = min(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
printf("%d", dp[n - 1]);
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
using namespace std;
typedef long long ll;
int main() {
int n, h[100000];
ll dp[100010];
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d", &h[i]);
for (int i = 0; i < n; i++)
dp[i] = 2000000000;
dp[0] = 0;
dp[1] = abs(h[0] - h[1]);
for (int i = 2; i < n; i++) {
dp[i] = min(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
dp[i] = min(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
printf("%d", dp[n - 1]);
return 0;
} | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"assignment.value.change"
] | 955,291 | 955,289 | u673980701 | cpp |
p03160 | #include <algorithm>
#include <cmath>
#include <cstdio>
using namespace std;
typedef long long ll;
int main() {
int n;
ll h[100000], dp[100010];
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d", &h[i]);
for (int i = 0; i < n; i++)
dp[i] = 100000;
dp[0] = 0;
dp[1] = abs(h[0] - h[1]);
for (int i = 2; i < n; i++) {
dp[i] = min(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
dp[i] = min(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
printf("%d", dp[n - 1]);
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
using namespace std;
typedef long long ll;
int main() {
int n, h[100000];
ll dp[100010];
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d", &h[i]);
for (int i = 0; i < n; i++)
dp[i] = 2000000000;
dp[0] = 0;
dp[1] = abs(h[0] - h[1]);
for (int i = 2; i < n; i++) {
dp[i] = min(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
dp[i] = min(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
printf("%d", dp[n - 1]);
return 0;
} | [
"literal.number.change",
"assignment.value.change"
] | 955,292 | 955,289 | u673980701 | cpp |
p03160 | #include <algorithm>
#include <cmath>
#include <cstdio>
using namespace std;
typedef long long ll;
int main() {
int n, h[100000];
ll dp[100010];
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d", &h[i]);
for (int i = 0; i < n; i++)
dp[i] = 100000;
dp[0] = 0;
dp[1] = abs(h[0] - h[1]);
for (int i = 2; i < n; i++) {
dp[i] = min(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
dp[i] = min(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
printf("%d", dp[n - 1]);
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
using namespace std;
typedef long long ll;
int main() {
int n, h[100000];
ll dp[100010];
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d", &h[i]);
for (int i = 0; i < n; i++)
dp[i] = 2000000000;
dp[0] = 0;
dp[1] = abs(h[0] - h[1]);
for (int i = 2; i < n; i++) {
dp[i] = min(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
dp[i] = min(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
printf("%d", dp[n - 1]);
return 0;
} | [
"literal.number.change",
"assignment.value.change"
] | 955,293 | 955,289 | u673980701 | cpp |
p03160 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define FORD(i, a, b) for (int i = (a); i >= (b); --i)
#define RI(i, n) FOR(i, 1, (n))
#define REP(i, n) FOR(i, 0, (n)-1)
#define mini(a, b) a = min(a, b)
#define maxi(a, b) a = max(a, b)
#define mp make_pair
#define pb push_back
#define st first
#define nd second
#define sz(w) (int)w.size()
typedef vector<int> vi;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<pii, int> para;
const ll inf = 2e18 + 7;
const int maxN = 2e6 + 5;
const ll MOD = 1e9 + 7;
int n, h[maxN], dp[maxN];
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
REP(i, n) cin >> h[i];
dp[0] = 0;
dp[1] = abs(h[1] - h[0]);
RI(i, n - 1) {
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 <algorithm>
#include <assert.h>
#include <bitset>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define FORD(i, a, b) for (int i = (a); i >= (b); --i)
#define RI(i, n) FOR(i, 1, (n))
#define REP(i, n) FOR(i, 0, (n)-1)
#define mini(a, b) a = min(a, b)
#define maxi(a, b) a = max(a, b)
#define mp make_pair
#define pb push_back
#define st first
#define nd second
#define sz(w) (int)w.size()
typedef vector<int> vi;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<pii, int> para;
const ll inf = 2e18 + 7;
const int maxN = 2e6 + 5;
const ll MOD = 1e9 + 7;
int n, h[maxN], dp[maxN];
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
REP(i, n) cin >> h[i];
dp[0] = 0;
dp[1] = abs(h[1] - h[0]);
FOR(i, 2, n - 1) {
dp[i] =
min(dp[i - 2] + abs(h[i] - h[i - 2]), dp[i - 1] + abs(h[i] - h[i - 1]));
// cout << dp[i] << " ";
}
cout << dp[n - 1];
return 0;
}
| [
"identifier.change",
"call.function.change",
"call.arguments.add"
] | 955,294 | 955,295 | u101662185 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int h[n + 1];
h[0] = 0;
for (int i = 1; i <= n; i++)
cin >> h[i];
int dp[n + 1];
dp[0] = 0;
dp[1] = 0;
for (int i = 2; i <= n; i++) {
dp[i] =
min(dp[i - 1] + abs(h[i] - h[i - 1]), dp[i - 2] + abs(h[i] - h[i - 2]));
}
cout << dp[n] << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int h[n + 1];
h[0] = 0;
for (int i = 1; i <= n; i++)
cin >> h[i];
int dp[n + 1];
dp[0] = 10001;
dp[1] = 0;
for (int i = 2; i <= n; i++) {
dp[i] =
min(dp[i - 1] + abs(h[i] - h[i - 1]), dp[i - 2] + abs(h[i] - h[i - 2]));
}
cout << dp[n] << endl;
} | [
"literal.number.change",
"assignment.value.change"
] | 955,298 | 955,299 | u422029489 | cpp |
p03160 | #include <bits/stdc++.h>
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define sz(x) ll(x.size())
using namespace std;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
int main() {
ll n, INF = 10000000000;
cin >> n;
vector<ll> h(n);
rep(i, n) cin >> h.at(i);
vector<ll> dp(n + 5, INF);
dp.at(0) = 0;
rep(i, n - 2) {
chmin(dp[i + 1], dp[i] + abs(h[i + 1] - h[i]));
chmin(dp[i + 2], dp[i] + abs(h[i + 2] - h[i]));
}
cout << dp[n - 1] << endl;
}
| #include <bits/stdc++.h>
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define sz(x) ll(x.size())
using namespace std;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
int main() {
ll n, INF = 10000000000;
cin >> n;
vector<ll> h(n);
rep(i, n) cin >> h.at(i);
vector<ll> dp(n + 5, INF);
dp.at(0) = 0;
rep(i, n - 1) {
chmin(dp[i + 1], dp[i] + abs(h[i + 1] - h[i]));
chmin(dp[i + 2], dp[i] + abs(h[i + 2] - h[i]));
}
cout << dp[n - 1] << endl;
}
| [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 955,307 | 955,308 | u059207724 | cpp |
p03160 | // CODE by Kazhybay Askar
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define iter set<int>::iterator
#define f first
#define s second
#define pb push_back
#define pf push_front
#define ppb pop_back
#define ppf pop_front
#define mp make_pair
#define cont continue
#define Speed ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
#define sz size()
#define all(x) x.begin(), x.end()
#define cont continue
#define r0 return 0
#define endl '\n'
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef pair<int, int> pii;
typedef pair<char, char> pcc;
const int MAXN = 1e5 + 7;
const int MOD = 1e9 + 7;
const int INF = 1e9 + 7;
const ll MINF = 1e18 + 7;
const int EPS = 1e-6;
const int dx[] = {0, 0, 1, -1, -1, -1, 1, 1};
const int dy[] = {1, -1, 0, 0, -1, 1, -1, 1};
const double pi = acos(-1.0);
ll a[MAXN], b[MAXN], dp[MAXN];
vector<int> g[MAXN], v;
bool used[MAXN];
ll n, m, k, cnt, sum, ans, mx, mn = INF;
bool y;
void freopen() {
freopen("A.in", "r", stdin);
freopen("A.out", "w", stdout);
}
void solve() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
dp[i] = INF;
}
dp[1] = 0;
for (int i = 1; i <= n; i++) {
dp[i] = min(dp[i], dp[i - 1] + abs(a[i - 1] - a[i]));
if (i > 1)
dp[i] = min(dp[i], dp[i - 2] + abs(a[i - 2] - a[i]));
}
cout << dp[n];
}
int main() {
Speed;
ll T = 1;
// cin>>T;
while (T--) {
solve();
}
r0;
}
| // CODE by Kazhybay Askar
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define iter set<int>::iterator
#define f first
#define s second
#define pb push_back
#define pf push_front
#define ppb pop_back
#define ppf pop_front
#define mp make_pair
#define cont continue
#define Speed ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
#define sz size()
#define all(x) x.begin(), x.end()
#define cont continue
#define r0 return 0
#define endl '\n'
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef pair<int, int> pii;
typedef pair<char, char> pcc;
const int MAXN = 1e5 + 7;
const int MOD = 1e9 + 7;
const int INF = 1e9 + 7;
const ll MINF = 1e18 + 7;
const int EPS = 1e-6;
const int dx[] = {0, 0, 1, -1, -1, -1, 1, 1};
const int dy[] = {1, -1, 0, 0, -1, 1, -1, 1};
const double pi = acos(-1.0);
ll a[MAXN], b[MAXN], dp[MAXN];
vector<int> g[MAXN], v;
bool used[MAXN];
ll n, m, k, cnt, sum, ans, mx, mn = INF;
bool y;
void freopen() {
freopen("A.in", "r", stdin);
freopen("A.out", "w", stdout);
}
void solve() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
dp[i] = INF;
}
dp[1] = 0;
for (int i = 2; i <= n; i++) {
dp[i] = min(dp[i], dp[i - 1] + abs(a[i - 1] - a[i]));
if (i > 2)
dp[i] = min(dp[i], dp[i - 2] + abs(a[i - 2] - a[i]));
}
cout << dp[n];
}
int main() {
Speed;
ll T = 1;
// cin>>T;
while (T--) {
solve();
}
r0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"control_flow.branch.if.condition.change"
] | 955,311 | 955,312 | u955953023 | cpp |
p03160 | #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int *h = new int[n];
for (int i = 0; i < n; i++)
cin >> h[i];
int *dp = new int[n];
dp[0] = 0;
dp[1] = abs(h[1] - h[0]);
for (int i = 0; i < n; i++) {
int t1, t2;
t1 = h[i - 1] + abs(h[i - 1] - h[i]);
t2 = h[i - 2] + abs(h[i - 2] - h[i]);
dp[i] = min(t1, t2);
}
cout << dp[n - 1];
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int *h = new int[n];
for (int i = 0; i < n; i++)
cin >> h[i];
int *dp = new int[n];
dp[0] = 0;
dp[1] = abs(h[1] - h[0]);
for (int i = 2; i < n; i++) {
int t1, t2;
t1 = dp[i - 1] + abs(h[i - 1] - h[i]);
t2 = dp[i - 2] + abs(h[i - 2] - h[i]);
dp[i] = min(t1, t2);
}
cout << dp[n - 1];
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 955,313 | 955,314 | u492511953 | cpp |
p03160 | // Program.cpp
// Problem Statement -
#include <algorithm>
#include <bits/stdc++.h>
#include <map>
#include <unordered_map>
using namespace std;
// Author: Varun Goyal (@govarun)
#define f(i, n) for (int i = 0; i < (n); ++i)
#define fa(i, a, n) for (int i = (a); i <= (n); ++i)
#define fd(i, a, n) for (int i = (a); i >= (n); --i)
#define all(x) x.begin(), x.end()
#define sz(x) (int)(x).size()
#define fill(a) memset(a, 0, sizeof(a))
#define ff first
#define ss second
#define mp make_pair
#define pb push_back
#define popb pop_back
#define ull unsigned long long
#define debug \
if (GOVARUN) \
cerr
#define d0(x) debug << #x << " = " << x << ' '
#define d1(x) debug << "> " << #x << " = " << x << '\n'
#define d2(x, y) \
debug << "> " << #x << " = " << x << ' ' << #y << " = " << y << '\n'
#define d3(x, y, z) \
debug << "> " << #x << " = " << x << ' ' << #y << " = " << y << ' ' << #z \
<< " = " << z << '\n'
#define endl '\n'
typedef long double ld;
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<pair<int, int>> vpii;
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
inline int two(int n) { return 1 << n; }
const ll mod = 1e9 + 7;
const int maxn = 1e5 + 5;
void pre() {}
void solve();
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
#ifdef GOVARUN
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#else
#define GOVARUN 0
#endif
int TC = 1;
// cin >> TC;
while (TC--) {
solve();
}
return 0;
}
void solve() {
int n;
cin >> n;
int h[n];
f(i, n) cin >> h[i];
int cost[n];
fill(cost);
cost[0] = 0;
if (n == 1)
cout << 0;
else if (n == 2)
cout << abs(h[1] - h[0]);
else {
cost[0] = 0;
cost[1] = abs(h[1] - h[0]);
fa(i, 2, n - 1) {
cost[i] = min(cost[i - 1] + abs(h[i] - h[i - 1]),
cost[i - 2] + abs(h[i] - h[i - 2]));
}
}
cout << cost[n - 1];
} | // Program.cpp
// Problem Statement -
#include <algorithm>
#include <bits/stdc++.h>
#include <map>
#include <unordered_map>
using namespace std;
// Author: Varun Goyal (@govarun)
#define f(i, n) for (int i = 0; i < (n); ++i)
#define fa(i, a, n) for (int i = (a); i <= (n); ++i)
#define fd(i, a, n) for (int i = (a); i >= (n); --i)
#define all(x) x.begin(), x.end()
#define sz(x) (int)(x).size()
#define fill(a) memset(a, 0, sizeof(a))
#define ff first
#define ss second
#define mp make_pair
#define pb push_back
#define popb pop_back
#define ull unsigned long long
#define debug \
if (GOVARUN) \
cerr
#define d0(x) debug << #x << " = " << x << ' '
#define d1(x) debug << "> " << #x << " = " << x << '\n'
#define d2(x, y) \
debug << "> " << #x << " = " << x << ' ' << #y << " = " << y << '\n'
#define d3(x, y, z) \
debug << "> " << #x << " = " << x << ' ' << #y << " = " << y << ' ' << #z \
<< " = " << z << '\n'
#define endl '\n'
typedef long double ld;
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<pair<int, int>> vpii;
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
inline int two(int n) { return 1 << n; }
const ll mod = 1e9 + 7;
const int maxn = 1e5 + 5;
void pre() {}
void solve();
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
#ifdef GOVARUN
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#else
#define GOVARUN 0
#endif
int TC = 1;
// cin >> TC;
while (TC--) {
solve();
}
return 0;
}
void solve() {
int n;
cin >> n;
int h[n];
f(i, n) cin >> h[i];
ll cost[n];
fill(cost);
cost[0] = 0;
if (n == 1)
cout << 0;
else if (n == 2)
cout << abs(h[1] - h[0]);
else {
cost[0] = 0;
cost[1] = abs(h[1] - h[0]);
fa(i, 2, n - 1) {
cost[i] = min(cost[i - 1] + abs(h[i] - h[i - 1]),
cost[i - 2] + abs(h[i] - h[i - 2]));
}
cout << cost[n - 1];
}
} | [
"variable_declaration.type.change"
] | 955,328 | 955,329 | u684375950 | cpp |
p03160 | #include <iostream>
#include <vector>
using namespace std;
const int INF = 10e+5;
int main() {
// your code goes here
int n, a;
cin >> n;
vector<int> h(n);
vector<int> dp(n, INF);
for (int i = 0; i < n; i++) {
cin >> a;
h[i] = a;
}
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < i + 3; j++) {
if (j < n) {
dp[j] = min(dp[j], dp[i] + abs(h[i] - h[j]));
}
}
}
cout << dp[n - 1] << endl;
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
const int INF = 1e9 + 5;
int main() {
// your code goes here
int n, a;
cin >> n;
vector<int> h(n);
vector<int> dp(n, INF);
for (int i = 0; i < n; i++) {
cin >> a;
h[i] = a;
}
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < i + 3; j++) {
if (j < n) {
dp[j] = min(dp[j], dp[i] + abs(h[i] - h[j]));
}
}
}
cout << dp[n - 1] << endl;
return 0;
} | [
"literal.number.change"
] | 955,336 | 955,337 | u819054341 | cpp |
p03160 | #include <iostream>
#include <math.h>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n, temp;
cin >> n;
vector<int> cost;
for (int i = 0; i < n; i++) {
cin >> temp;
cost.push_back(temp);
}
vector<int> dp(n, 0);
dp[0] = cost[0];
dp[1] = abs(cost[1] - cost[0]);
for (int i = 2; i < n; i++) {
dp[i] = min(dp[i - 2] + abs(cost[i] - cost[i - 2]),
dp[i - 1] + abs(cost[i] - cost[i - 1]));
}
cout << dp[n - 1];
} | #include <iostream>
#include <math.h>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n, temp;
cin >> n;
vector<int> cost;
for (int i = 0; i < n; i++) {
cin >> temp;
cost.push_back(temp);
}
vector<int> dp(n, 0);
dp[0] = 0;
dp[1] = abs(cost[1] - cost[0]);
for (int i = 2; i < n; i++) {
dp[i] = min(dp[i - 2] + abs(cost[i] - cost[i - 2]),
dp[i - 1] + abs(cost[i] - cost[i - 1]));
}
cout << dp[n - 1];
} | [] | 955,344 | 955,345 | u764355221 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int cost[n];
for (int i = 0; i < n; i++)
cin >> cost[i];
long dp[n];
dp[0] = 0;
dp[1] = abs(cost[1]);
for (int i = 2; i < n; i++) {
dp[i] = min(dp[i - 2] + abs(cost[i - 2] - cost[i]),
dp[i - 1] + abs(cost[i - 1] - cost[i]));
}
cout << dp[n - 1] << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int cost[n];
for (int i = 0; i < n; i++)
cin >> cost[i];
long dp[n];
dp[0] = 0;
dp[1] = abs(cost[1] - cost[0]);
for (int i = 2; i < n; i++) {
dp[i] = min(dp[i - 2] + abs(cost[i - 2] - cost[i]),
dp[i - 1] + abs(cost[i - 1] - cost[i]));
}
cout << dp[n - 1] << endl;
} | [
"assignment.change"
] | 955,346 | 955,347 | u371051907 | cpp |
p03160 | #include <algorithm>
#include <cmath>
#include <iostream>
using namespace std;
long long N;
int main() {
long long i, h[100005], d[100005];
cin >> N;
h[0] = 0;
d[1] = 0;
d[0] = -1000000000;
for (i = 1; i <= N; i++)
cin >> h[i];
for (i = 2; i <= N; i++) {
d[i] =
min(d[i - 1] + abs(h[i] - h[i - 1]), d[i - 2] + abs(h[i] - h[i - 2]));
}
cout << d[N];
} | #include <algorithm>
#include <cmath>
#include <iostream>
using namespace std;
long long N;
int main() {
long long i, h[100005], d[100005];
cin >> N;
h[0] = 0;
d[1] = 0;
d[0] = 1000000000;
for (i = 1; i <= N; i++)
cin >> h[i];
for (i = 2; i <= N; i++) {
d[i] =
min(d[i - 1] + abs(h[i] - h[i - 1]), d[i - 2] + abs(h[i] - h[i - 2]));
}
cout << d[N];
} | [
"expression.operation.unary.arithmetic.remove"
] | 955,350 | 955,351 | u432635701 | cpp |
p03160 | #include <algorithm>
#include <cmath>
#include <iostream>
using namespace std;
long long N;
int main() {
long long i, h[100005], d[100005];
cin >> N;
h[0] = 0;
d[1] = 0;
d[0] = 0;
for (i = 1; i <= N; i++)
cin >> h[i];
for (i = 2; i <= N; i++) {
d[i] =
min(d[i - 1] + abs(h[i] - h[i - 1]), d[i - 2] + abs(h[i] - h[i - 2]));
}
cout << d[N];
} | #include <algorithm>
#include <cmath>
#include <iostream>
using namespace std;
long long N;
int main() {
long long i, h[100005], d[100005];
cin >> N;
h[0] = 0;
d[1] = 0;
d[0] = 1000000000;
for (i = 1; i <= N; i++)
cin >> h[i];
for (i = 2; i <= N; i++) {
d[i] =
min(d[i - 1] + abs(h[i] - h[i - 1]), d[i - 2] + abs(h[i] - h[i - 2]));
}
cout << d[N];
} | [
"literal.number.change",
"assignment.value.change"
] | 955,352 | 955,351 | u432635701 | cpp |
p03160 | #include <algorithm>
#include <cmath>
#include <iostream>
using namespace std;
int N;
int main() {
int i, h[100005], d[100005];
cin >> N;
h[0] = 0;
d[1] = 0;
d[0] = 0;
for (i = 1; i <= N; i++)
cin >> h[i];
for (i = 2; i <= N; i++) {
d[i] =
min(d[i - 1] + abs(h[i] - h[i - 1]), d[i - 2] + abs(h[i] - h[i - 2]));
}
cout << d[N];
} | #include <algorithm>
#include <cmath>
#include <iostream>
using namespace std;
long long N;
int main() {
long long i, h[100005], d[100005];
cin >> N;
h[0] = 0;
d[1] = 0;
d[0] = 1000000000;
for (i = 1; i <= N; i++)
cin >> h[i];
for (i = 2; i <= N; i++) {
d[i] =
min(d[i - 1] + abs(h[i] - h[i - 1]), d[i - 2] + abs(h[i] - h[i - 2]));
}
cout << d[N];
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"literal.number.change",
"assignment.value.change"
] | 955,353 | 955,351 | u432635701 | cpp |
p03160 | #include <iostream>
#include <vector>
int main() {
int n;
std::cin >> n;
std::vector<int> h;
for (int i = 0; i < n; i++) {
int value;
std::cin >> value;
h.push_back(value);
}
std::vector<int> dp(n + 1);
dp[1] = abs(h[1] - h[0]);
dp[2] = std::min(abs(h[2] - h[0]), dp[1] + h[2] - h[0]);
for (int i = 3; 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 << dp[n - 1];
return 0;
} | #include <iostream>
#include <vector>
int main() {
int n;
std::cin >> n;
std::vector<int> h;
for (int i = 0; i < n; i++) {
int value;
std::cin >> value;
h.push_back(value);
}
std::vector<int> dp(n + 1);
dp[1] = abs(h[1] - h[0]);
dp[2] = std::min(abs(h[2] - h[0]), dp[1] + abs(h[2] - h[0]));
for (int i = 3; 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 << dp[n - 1];
return 0;
} | [
"call.add",
"call.arguments.change"
] | 955,354 | 955,355 | u290926443 | cpp |
p03160 | #include <algorithm>
#include <bits/stdc++.h>
#include <cstring>
#include <iostream>
using namespace std;
const int N = 1e3 + 6, M = 1e5 + 5, OO = 0x3f3f3f3f;
int n, arr[N], op1, op2, dp[N];
int frog(int i) {
if (i < 0)
return 0;
if (dp[i] != -1)
return dp[i];
op1 = abs(arr[i] - arr[i - 1]) + frog(i - 1);
op2 = abs(arr[i] - arr[i - 2]) + frog(i - 2);
return dp[i] = min(op1, op2);
}
int main() {
dp[0] = 0;
scanf("%d", &n);
memset(dp, -1, sizeof dp);
for (int i = 0; i < n; i++)
scanf("%d", arr + i);
dp[1] = abs(arr[1] - arr[0]);
printf("%d\n", frog(n - 1));
return 0;
}
| #include <algorithm>
#include <bits/stdc++.h>
#include <cstring>
#include <iostream>
using namespace std;
const int N = 1e5 + 6, M = 1e5 + 5, OO = 0x3f3f3f3f;
int n, arr[N], op1, op2, dp[N];
int frog(int i) {
if (i <= 0)
return 0;
if (dp[i] != -1)
return dp[i];
op1 = abs(arr[i] - arr[i - 1]) + frog(i - 1);
op2 = abs(arr[i] - arr[i - 2]) + frog(i - 2);
return dp[i] = min(op1, op2);
}
int main() {
dp[0] = 0;
scanf("%d", &n);
memset(dp, -1, sizeof dp);
for (int i = 0; i < n; i++)
scanf("%d", arr + i);
dp[1] = abs(arr[1] - arr[0]);
printf("%d\n", frog(n - 1));
return 0;
}
| [
"literal.number.change",
"expression.operation.binary.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 955,358 | 955,357 | u266150970 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int dp[1100];
for (int i = 0; i < 110000; i++)
dp[i] = 1000000000;
int h[N];
for (int i = 0; i < N; i++)
cin >> h[i];
dp[0] = 0;
dp[1] = abs(h[1] - h[0]);
// cout<<dp[0]<<endl<<dp[1]<<endl;
for (int i = 2; i < N; i++) {
dp[i] =
min(dp[i - 1] + abs(h[i] - h[i - 1]), dp[i - 2] + abs(h[i] - h[i - 2]));
// cout<<dp[i]<<endl;
}
cout << dp[N - 1] << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int dp[110000];
for (int i = 0; i < 110000; i++)
dp[i] = 1000000000;
int h[N];
for (int i = 0; i < N; i++)
cin >> h[i];
dp[0] = 0;
dp[1] = abs(h[1] - h[0]);
// cout<<dp[0]<<endl<<dp[1]<<endl;
for (int i = 2; i < N; i++) {
dp[i] =
min(dp[i - 1] + abs(h[i] - h[i - 1]), dp[i - 2] + abs(h[i] - h[i - 2]));
// cout<<dp[i]<<endl;
}
cout << dp[N - 1] << endl;
} | [
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 955,363 | 955,364 | u652009496 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int h[n];
for (int i = 0; i < n; i++)
cin >> h[n];
int cost[n] = {0};
cost[1] = abs(h[0] - h[1]);
cost[2] = min(abs(h[0] - h[2]), cost[1] + abs(h[1] - h[2]));
for (int i = 3; i < n; i++)
cost[i] = min(cost[i - 1] + abs(h[i - 1] - h[i]),
cost[i - 2] + abs(h[i - 2] - h[i]));
cout << cost[n - 1];
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int h[n];
for (int i = 0; i < n; i++)
cin >> h[i];
int cost[n] = {0};
cost[1] = abs(h[0] - h[1]);
cost[2] = min(abs(h[0] - h[2]), cost[1] + abs(h[1] - h[2]));
for (int i = 3; i < n; i++)
cost[i] = min(cost[i - 1] + abs(h[i - 1] - h[i]),
cost[i - 2] + abs(h[i - 2] - h[i]));
cout << cost[n - 1];
} | [
"identifier.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 955,368 | 955,369 | u231447805 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define all(v) (v).begin(), (v).end()
#define lp(i, n) for (int i = 0; i < (n); ++i)
#define lpp(i, n) for (int i = 1; i <= (n); ++i)
#define sz(v) (int)(v).size()
#define int long long
#define mod 100000007
string x;
int32_t main() {
int n, t;
cin >> n;
int arr[n + 1];
lpp(i, n) cin >> arr[i];
int dp[n + 1];
arr[0] = 0;
dp[0] = 0;
dp[1] = 0;
for (int j = 2; j <= n; ++j) {
dp[j] = min(dp[j - 1] + abs(arr[j] - arr[j - 1]),
dp[j - 2] + abs(arr[j] - arr[j - 2]));
}
cout << dp[n];
}
| #include <bits/stdc++.h>
using namespace std;
#define all(v) (v).begin(), (v).end()
#define lp(i, n) for (int i = 0; i < (n); ++i)
#define lpp(i, n) for (int i = 1; i <= (n); ++i)
#define sz(v) (int)(v).size()
#define int long long
#define mod 100000007
string x;
int32_t main() {
int n, t;
cin >> n;
int arr[n + 1];
lpp(i, n) cin >> arr[i];
int dp[n + 1];
arr[0] = 100000000000;
dp[0] = 0;
dp[1] = 0;
for (int j = 2; j <= n; ++j) {
dp[j] = min(dp[j - 1] + abs(arr[j] - arr[j - 1]),
dp[j - 2] + abs(arr[j] - arr[j - 2]));
}
cout << dp[n];
}
| [
"literal.number.change",
"assignment.value.change"
] | 955,372 | 955,373 | u090634452 | cpp |
p03160 | #include <bits/stdc++.h>
#define IO ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
using namespace std;
typedef long long ll;
typedef struct data {
ll x, y;
bool operator<(const data &a) const { return x < a.x; }
} stu;
ll n, m, k, x;
ll arr[600000];
ll dp[600000];
void solve() {
x = 999999999l;
memset(dp, x, sizeof dp);
memset(arr, x, sizeof arr);
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> arr[i];
}
// dp
dp[n - 1] = 0;
for (int i = n - 2; i >= 0; i--) {
dp[i] = min(dp[i + 1] + abs(arr[i] - arr[i + 1]),
dp[i + 2] + abs(arr[i] - arr[i + 2]));
}
cout << dp[0] << endl;
// end dp
}
int main() {
// clock_t startTime = clock();
solve();
// cout << double( clock() - startTime ) / (double)CLOCKS_PER_SEC<< endl;
return 0;
} | #include <bits/stdc++.h>
#define IO ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
using namespace std;
typedef long long ll;
typedef struct data {
ll x, y;
bool operator<(const data &a) const { return x < a.x; }
} stu;
ll n, m, k, x;
ll arr[600000];
ll dp[600000];
void solve() {
x = 10000;
memset(dp, x, sizeof dp);
memset(arr, x, sizeof arr);
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> arr[i];
}
// dp
dp[n - 1] = 0;
for (int i = n - 2; i >= 0; i--) {
dp[i] = min(dp[i + 1] + abs(arr[i] - arr[i + 1]),
dp[i + 2] + abs(arr[i] - arr[i + 2]));
}
cout << dp[0] << endl;
// end dp
}
int main() {
// clock_t startTime = clock();
solve();
// cout << double( clock() - startTime ) / (double)CLOCKS_PER_SEC<< endl;
return 0;
} | [
"literal.number.change",
"assignment.value.change"
] | 955,374 | 955,375 | u090634452 | cpp |
p03160 | #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <queue>
#include <string>
#include <utility>
#include <vector>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main() {
int n, h[100001], dp[100001];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> h[i];
dp[i] = 1000000;
}
dp[0] = 0;
for (int i = 1; i < n; i++) {
chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
if (i > 1)
chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
cout << dp[n - 1] << endl;
return 0;
}
| #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <queue>
#include <string>
#include <utility>
#include <vector>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main() {
int n, h[100001];
long long dp[100001];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> h[i];
dp[i] = 10000000000;
}
dp[0] = 0;
for (int i = 1; i < n; i++) {
chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
if (i > 1)
chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
cout << dp[n - 1] << endl;
return 0;
}
| [
"literal.number.change",
"assignment.value.change"
] | 955,378 | 955,379 | u342005896 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
void solve();
int main() {
// freopen("SNOOKER.inp","r",stdin);
// freopen("SNOOKER.out","w",stdout);
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
solve();
}
/*----------------------------------------------------------------------
-----------------------------------------------------------------------*/
using ll = long long;
#define endl "\n"
#define eb emplace_back
#define all(x) x.begin(), x.end()
#define what_is(x) cerr << #x << " is :" << (x) << endl
const int MOD = 1e9 + 7;
const ll inf = LLONG_MAX;
const int MAX_N = 1e5 + 7;
int n;
ll a[MAX_N], dp[MAX_N];
void solve() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
dp[0] = dp[1] = 0;
dp[2] = abs(a[2] - a[1]);
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]);
}
// for(int i = 1; i <= cur_lenght; i++) cout << tail[i] << endl;
cout << dp[n];
}
| #include <bits/stdc++.h>
using namespace std;
void solve();
int main() {
// freopen("SNOOKER.inp","r",stdin);
// freopen("SNOOKER.out","w",stdout);
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
solve();
}
/*----------------------------------------------------------------------
-----------------------------------------------------------------------*/
using ll = long long;
#define endl "\n"
#define eb emplace_back
#define all(x) x.begin(), x.end()
#define what_is(x) cerr << #x << " is :" << (x) << endl
const int MOD = 1e9 + 7;
const ll inf = LLONG_MAX;
const int MAX_N = 1e5 + 7;
int n;
ll a[MAX_N], dp[MAX_N];
void solve() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
dp[0] = dp[1] = 0;
dp[2] = abs(a[2] - a[1]);
for (int i = 3; i <= n; i++) {
dp[i] =
min(abs(a[i] - a[i - 1]) + dp[i - 1], abs(a[i] - a[i - 2]) + dp[i - 2]);
}
// for(int i = 1; i <= cur_lenght; i++) cout << tail[i] << endl;
cout << dp[n];
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 955,380 | 955,381 | u307631662 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
long long a[t] = {0}, b[t] = {0};
for (long long i = 0; i < t; i++) {
cin >> a[i];
if (i == 0) {
b[i] = 0;
} else if (i == 1) {
b[i] = (abs(a[1] - a[0]));
} else if (i == 2) {
long long y = (abs(a[2] - a[1])) + (abs(a[1]) - a[0]);
long long z = (abs(a[2] - a[0]));
if (y < z) {
b[i] = y;
} else {
b[i] = z;
}
} else {
long long p = (abs(a[i] - a[i - 2])) + b[i - 2];
long long q = (abs(a[i] - a[i - 1])) + b[i - 1];
if (p < q) {
b[i] = p;
} else {
b[i] = q;
}
}
}
cout << b[t - 1] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
long long a[t] = {0}, b[t] = {0};
for (long long i = 0; i < t; i++) {
cin >> a[i];
if (i == 0) {
b[i] = 0;
} else if (i == 1) {
b[i] = (abs(a[1] - a[0]));
} else if (i == 2) {
long long y = (abs(a[2] - a[1])) + (abs(a[1] - a[0]));
long long z = (abs(a[2] - a[0]));
if (y < z) {
b[i] = y;
} else {
b[i] = z;
}
} else {
long long p = (abs(a[i] - a[i - 2])) + b[i - 2];
long long q = (abs(a[i] - a[i - 1])) + b[i - 1];
if (p < q) {
b[i] = p;
} else {
b[i] = q;
}
}
}
cout << b[t - 1] << endl;
return 0;
} | [
"call.arguments.change"
] | 955,388 | 955,389 | u389477056 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
#define pb push_back
typedef long long ll;
const int INF = 1000000000;
const long INF64 = 1000000000000000ll;
const ll MOD = 1000000007ll;
int main() {
int n;
std::cin >> n;
std::vector<int> a(n), ans(n, 0);
rep(i, n) std::cin >> a[i];
ans[0] = a[0];
ans[1] = abs(a[1] - a[0]);
for (int i = 2; i < n; i++) {
/* code */
ans[i] = min(ans[i - 2] + abs(a[i] - a[i - 2]),
ans[i - 1] + abs(a[i] - a[i - 1]));
}
std::cout << ans[n - 1] << std::endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
#define pb push_back
typedef long long ll;
const int INF = 1000000000;
const long INF64 = 1000000000000000ll;
const ll MOD = 1000000007ll;
int main() {
int n;
std::cin >> n;
std::vector<int> a(n), ans(n, 0);
rep(i, n) std::cin >> a[i];
ans[0] = 0;
ans[1] = abs(a[1] - a[0]);
for (int i = 2; i < n; i++) {
/* code */
ans[i] = min(ans[i - 2] + abs(a[i] - a[i - 2]),
ans[i - 1] + abs(a[i] - a[i - 1]));
}
std::cout << ans[n - 1] << std::endl;
}
| [] | 955,395 | 955,396 | u539011156 | cpp |
p03160 | #include <bits/stdc++.h> /*
#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp> // Including */
using namespace std;
// using namespace __gnu_pbds;
// typedefs
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;
typedef pair<ll, ll> pll;
typedef vector<pii> vii;
typedef vector<pll> vll;
typedef vector<int>::iterator vit;
typedef set<int>::iterator sit;
/*
template<typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag,
tree_order_statistics_node_update>; template<typename F, typename S> using
ordered_map = tree<F, S, less<F>, rb_tree_tag,
tree_order_statistics_node_update>;
*/
//#Defines
#define rep(i, a, b) for (i = a; i <= b; i++)
#define repR(i, a, b) for (i = a; i >= b; i--)
//#define pb push_back
#define pb emplace_back
#define F first
#define S second
#define mp make_pair
#define all(c) c.begin(), c.end()
#define endl '\n'
#define pf printf
#define sf scanf
//#define left __left
//#define right __right
//#define tree __tree
#define MOD 1000000007
//#define harmonic(n) 0.57721566490153286l+log(n)
#define RESET(a, b) memset(a, b, sizeof(a))
#define gcd(a, b) __gcd(a, b)
#define lcm(a, b) (a * (b / gcd(a, b)))
#define sqr(a) ((a) * (a))
#define optimize() \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define fraction() \
cout.unsetf(ios::floatfield); \
cout.precision(10); \
cout.setf(ios::fixed, ios::floatfield);
const double PI = acos(-1);
const double eps = 1e-9;
const int inf = 2000000000;
const ll infLL = 9000000000000000000;
// Bit Operations
inline bool checkBit(ll n, int i) { return n & (1LL << i); }
inline ll setBit(ll n, int i) {
return n | (1LL << i);
;
}
inline ll resetBit(ll n, int i) { return n & (~(1LL << i)); }
int fx[] = {0, 0, +1, -1};
int fy[] = {+1, -1, 0, 0};
// int dx[] = {+1, 0, -1, 0, +1, +1, -1, -1};
// int dy[] = {0, +1, 0, -1, +1, -1, +1, -1};
// Inline functions
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
inline bool isLeapYear(ll year) {
return (year % 400 == 0) || (year % 4 == 0 && year % 100 != 0);
}
inline void normal(ll &a) {
a %= MOD;
(a < 0) && (a += MOD);
}
inline ll modMul(ll a, ll b) {
a %= MOD, b %= MOD;
normal(a), normal(b);
return (a * b) % MOD;
}
inline ll modAdd(ll a, ll b) {
a %= MOD, b %= MOD;
normal(a), normal(b);
return (a + b) % MOD;
}
inline ll modSub(ll a, ll b) {
a %= MOD, b %= MOD;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
inline ll modPow(ll b, ll p) {
ll r = 1;
while (p) {
if (p & 1)
r = modMul(r, b);
b = modMul(b, b);
p >>= 1;
}
return r;
}
inline ll modInverse(ll a) { return modPow(a, MOD - 2); }
inline ll modDiv(ll a, ll b) { return modMul(a, modInverse(b)); }
inline bool isInside(pii p, ll n, ll m) {
return (p.first >= 0 && p.first < n && p.second >= 0 && p.second < m);
}
inline bool isInside(pii p, ll n) {
return (p.first >= 0 && p.first < n && p.second >= 0 && p.second < n);
}
inline bool isSquare(ll x) {
ll s = sqrt(x);
return (s * s == x);
}
inline bool isFib(ll x) {
return isSquare(5 * x * x + 4) || isSquare(5 * x * x - 4);
}
inline bool isPowerOfTwo(ll x) { return ((1LL << (ll)log2(x)) == x); }
struct func {
// this is a sample overloading function for sorting stl
bool operator()(pii const &a, pii const &b) {
if (a.F == b.F)
return (a.S < b.S);
return (a.F < b.F);
}
};
// Prime Number Generator
/*
#define M 100000000
int marked[M/64 + 2];
#define on(x) (marked[x/64] & (1<<((x%64)/2)))
#define mark(x) marked[x/64] |= (1<<((x%64)/2))
vl prime;
bool isPrime(int num) {
return num > 1 && (num == 2 || ((num & 1) && !on(num)));
}
void sieve(ll n) {
for (ll i = 3; i * i < n; i += 2) {
if (!on(i)) {
for (ll j = i * i; j <= n; j += i + i) {
mark(j);
}
}
}
prime.pb(2);
for(ll i = 3; i <= n; i += 2) {
if(!on(i)) prime.pb(i);
}
}
*/
//
// debug
#ifdef tajir
template <typename F, typename S>
ostream &operator<<(ostream &os, const pair<F, S> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin())
os << ", ";
os << *it;
}
return os << "}";
}
template <typename T> ostream &operator<<(ostream &os, const set<T> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin())
os << ", ";
os << *it;
}
return os << "]";
}
template <typename T> ostream &operator<<(ostream &os, const multiset<T> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin())
os << ", ";
os << *it;
}
return os << "]";
}
template <typename F, typename S>
ostream &operator<<(ostream &os, const map<F, S> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin())
os << ", ";
os << it->first << " = " << it->second;
}
return os << "]";
}
#define dbg(args...) \
do { \
cerr << #args << " : "; \
faltu(args); \
} while (0)
clock_t tStart = clock();
#define timeStamp \
dbg("Execution Time: ", (double)(clock() - tStart) / CLOCKS_PER_SEC)
void faltu() { cerr << endl; }
template <typename T> void faltu(T a[], int n) {
for (int i = 0; i < n; ++i)
cerr << a[i] << ' ';
cerr << endl;
}
template <typename T, typename... hello>
void faltu(T arg, const hello &...rest) {
cerr << arg << ' ';
faltu(rest...);
}
#else
#define dbg(args...)
#endif // tajir
int main() {
#ifdef tajir
freopen("input.txt", "r", stdin);
#else
// online submission
#endif
optimize();
int n;
cin >> n;
vi h(n + 1);
for (int i = 1; i <= n; ++i)
cin >> h[i];
vi dp(n + 1, 0);
for (int i = 2; i <= n; ++i) {
dp[i] = dp[i - 1] + abs(h[i] - h[i - 1]);
if (i - 2 >= 0)
dp[i] = min(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
cout << dp[n] << endl;
return 0;
}
| #include <bits/stdc++.h> /*
#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp> // Including */
using namespace std;
// using namespace __gnu_pbds;
// typedefs
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;
typedef pair<ll, ll> pll;
typedef vector<pii> vii;
typedef vector<pll> vll;
typedef vector<int>::iterator vit;
typedef set<int>::iterator sit;
/*
template<typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag,
tree_order_statistics_node_update>; template<typename F, typename S> using
ordered_map = tree<F, S, less<F>, rb_tree_tag,
tree_order_statistics_node_update>;
*/
//#Defines
#define rep(i, a, b) for (i = a; i <= b; i++)
#define repR(i, a, b) for (i = a; i >= b; i--)
//#define pb push_back
#define pb emplace_back
#define F first
#define S second
#define mp make_pair
#define all(c) c.begin(), c.end()
#define endl '\n'
#define pf printf
#define sf scanf
//#define left __left
//#define right __right
//#define tree __tree
#define MOD 1000000007
//#define harmonic(n) 0.57721566490153286l+log(n)
#define RESET(a, b) memset(a, b, sizeof(a))
#define gcd(a, b) __gcd(a, b)
#define lcm(a, b) (a * (b / gcd(a, b)))
#define sqr(a) ((a) * (a))
#define optimize() \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define fraction() \
cout.unsetf(ios::floatfield); \
cout.precision(10); \
cout.setf(ios::fixed, ios::floatfield);
const double PI = acos(-1);
const double eps = 1e-9;
const int inf = 2000000000;
const ll infLL = 9000000000000000000;
// Bit Operations
inline bool checkBit(ll n, int i) { return n & (1LL << i); }
inline ll setBit(ll n, int i) {
return n | (1LL << i);
;
}
inline ll resetBit(ll n, int i) { return n & (~(1LL << i)); }
int fx[] = {0, 0, +1, -1};
int fy[] = {+1, -1, 0, 0};
// int dx[] = {+1, 0, -1, 0, +1, +1, -1, -1};
// int dy[] = {0, +1, 0, -1, +1, -1, +1, -1};
// Inline functions
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
inline bool isLeapYear(ll year) {
return (year % 400 == 0) || (year % 4 == 0 && year % 100 != 0);
}
inline void normal(ll &a) {
a %= MOD;
(a < 0) && (a += MOD);
}
inline ll modMul(ll a, ll b) {
a %= MOD, b %= MOD;
normal(a), normal(b);
return (a * b) % MOD;
}
inline ll modAdd(ll a, ll b) {
a %= MOD, b %= MOD;
normal(a), normal(b);
return (a + b) % MOD;
}
inline ll modSub(ll a, ll b) {
a %= MOD, b %= MOD;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
inline ll modPow(ll b, ll p) {
ll r = 1;
while (p) {
if (p & 1)
r = modMul(r, b);
b = modMul(b, b);
p >>= 1;
}
return r;
}
inline ll modInverse(ll a) { return modPow(a, MOD - 2); }
inline ll modDiv(ll a, ll b) { return modMul(a, modInverse(b)); }
inline bool isInside(pii p, ll n, ll m) {
return (p.first >= 0 && p.first < n && p.second >= 0 && p.second < m);
}
inline bool isInside(pii p, ll n) {
return (p.first >= 0 && p.first < n && p.second >= 0 && p.second < n);
}
inline bool isSquare(ll x) {
ll s = sqrt(x);
return (s * s == x);
}
inline bool isFib(ll x) {
return isSquare(5 * x * x + 4) || isSquare(5 * x * x - 4);
}
inline bool isPowerOfTwo(ll x) { return ((1LL << (ll)log2(x)) == x); }
struct func {
// this is a sample overloading function for sorting stl
bool operator()(pii const &a, pii const &b) {
if (a.F == b.F)
return (a.S < b.S);
return (a.F < b.F);
}
};
// Prime Number Generator
/*
#define M 100000000
int marked[M/64 + 2];
#define on(x) (marked[x/64] & (1<<((x%64)/2)))
#define mark(x) marked[x/64] |= (1<<((x%64)/2))
vl prime;
bool isPrime(int num) {
return num > 1 && (num == 2 || ((num & 1) && !on(num)));
}
void sieve(ll n) {
for (ll i = 3; i * i < n; i += 2) {
if (!on(i)) {
for (ll j = i * i; j <= n; j += i + i) {
mark(j);
}
}
}
prime.pb(2);
for(ll i = 3; i <= n; i += 2) {
if(!on(i)) prime.pb(i);
}
}
*/
//
// debug
#ifdef tajir
template <typename F, typename S>
ostream &operator<<(ostream &os, const pair<F, S> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin())
os << ", ";
os << *it;
}
return os << "}";
}
template <typename T> ostream &operator<<(ostream &os, const set<T> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin())
os << ", ";
os << *it;
}
return os << "]";
}
template <typename T> ostream &operator<<(ostream &os, const multiset<T> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin())
os << ", ";
os << *it;
}
return os << "]";
}
template <typename F, typename S>
ostream &operator<<(ostream &os, const map<F, S> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin())
os << ", ";
os << it->first << " = " << it->second;
}
return os << "]";
}
#define dbg(args...) \
do { \
cerr << #args << " : "; \
faltu(args); \
} while (0)
clock_t tStart = clock();
#define timeStamp \
dbg("Execution Time: ", (double)(clock() - tStart) / CLOCKS_PER_SEC)
void faltu() { cerr << endl; }
template <typename T> void faltu(T a[], int n) {
for (int i = 0; i < n; ++i)
cerr << a[i] << ' ';
cerr << endl;
}
template <typename T, typename... hello>
void faltu(T arg, const hello &...rest) {
cerr << arg << ' ';
faltu(rest...);
}
#else
#define dbg(args...)
#endif // tajir
int main() {
#ifdef tajir
freopen("input.txt", "r", stdin);
#else
// online submission
#endif
optimize();
int n;
cin >> n;
vl h(n + 1);
for (int i = 1; i <= n; ++i)
cin >> h[i];
vl dp(n + 1, 0);
for (int i = 2; i <= n; ++i) {
dp[i] = dp[i - 1] + abs(h[i] - h[i - 1]);
if (i - 2 >= 1)
dp[i] = min(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
cout << dp[n] << endl;
return 0;
}
| [
"variable_declaration.type.change",
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 955,399 | 955,400 | u883391587 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 3;
long long h[N], dp[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
for (int i = 1; i <= n; ++i)
cin >> h[i];
for (int i = 2; i <= n; ++i) {
dp[i] = dp[i - 1] + abs(h[i] - h[i - 1]);
dp[i] = min(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
cout << dp[n];
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 3;
long long h[N], dp[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
for (int i = 1; i <= n; ++i)
cin >> h[i];
for (int i = 2; i <= n; ++i) {
dp[i] = dp[i - 1] + abs(h[i] - h[i - 1]);
if (i > 2)
dp[i] = min(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
cout << dp[n];
return 0;
} | [
"control_flow.branch.if.add"
] | 955,401 | 955,402 | u936529286 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
v.push_back(x);
}
vector<int> dp(v.size(), 1e6);
dp[0] = 0;
for (int i = 1; i < v.size(); i++) {
for (int j = i + 1; j <= i + 2; j++) {
if (j < v.size()) {
dp[j] = min(dp[j], dp[i] + abs(v[i] - v[j]));
}
}
}
cout << dp[v.size() - 1];
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
v.push_back(x);
}
vector<int> dp(v.size(), 1e9);
dp[0] = 0;
for (int i = 0; i < v.size(); i++) {
for (int j = i + 1; j <= i + 2; j++) {
if (j < v.size()) {
dp[j] = min(dp[j], dp[i] + abs(v[i] - v[j]));
}
}
}
cout << dp[v.size() - 1];
} | [
"literal.number.change",
"call.arguments.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 955,408 | 955,409 | u447297324 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
v.push_back(x);
}
vector<int> dp(v.size(), 1e6);
dp[0] = 0;
for (int i = 0; i < v.size(); i++) {
for (int j = i + 1; j <= i + 2; j++) {
if (j < v.size()) {
dp[j] = min(dp[j], dp[i] + abs(v[i] - v[j]));
}
}
}
cout << dp[v.size() - 1];
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
v.push_back(x);
}
vector<int> dp(v.size(), 1e9);
dp[0] = 0;
for (int i = 0; i < v.size(); i++) {
for (int j = i + 1; j <= i + 2; j++) {
if (j < v.size()) {
dp[j] = min(dp[j], dp[i] + abs(v[i] - v[j]));
}
}
}
cout << dp[v.size() - 1];
} | [
"literal.number.change",
"call.arguments.change"
] | 955,410 | 955,409 | u447297324 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define pi 3.14159265359
#define int long long
#define pii pair<int, int>
#define ld long double
const int mod = 1e9 + 7;
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, -1, 0, 1};
int bin(multiset<int> &s) {
int l = 0, r = s.size() - 1, mid, ans = 1;
while (l <= r) {
mid = (l + r) / 2;
auto k = s.begin();
advance(k, mid);
if (*k >= s.size() - mid) {
ans = s.size() - mid;
r = mid - 1;
} else
l = mid + 1;
}
return ans;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<int> v(n + 1);
for (int i = 1; i <= n; i++)
cin >> v[i];
vector<int> dp(100006);
dp[1] = 0, dp[2] = v[2] - v[1];
for (int i = 3; i <= n; i++) {
dp[i] =
min(dp[i - 1] + abs(v[i] - v[i - 1]), dp[i - 2] + abs(v[i] - v[i - 2]));
}
cout << dp[n];
} | #include <bits/stdc++.h>
using namespace std;
#define pi 3.14159265359
#define int long long
#define pii pair<int, int>
#define ld long double
const int mod = 1e9 + 7;
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, -1, 0, 1};
int bin(multiset<int> &s) {
int l = 0, r = s.size() - 1, mid, ans = 1;
while (l <= r) {
mid = (l + r) / 2;
auto k = s.begin();
advance(k, mid);
if (*k >= s.size() - mid) {
ans = s.size() - mid;
r = mid - 1;
} else
l = mid + 1;
}
return ans;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<int> v(n + 1);
for (int i = 1; i <= n; i++)
cin >> v[i];
vector<int> dp(100006);
dp[1] = 0, dp[2] = abs(v[2] - v[1]);
for (int i = 3; i <= n; i++) {
dp[i] =
min(dp[i - 1] + abs(v[i] - v[i - 1]), dp[i - 2] + abs(v[i] - v[i - 2]));
}
cout << dp[n];
} | [
"call.add",
"call.arguments.change"
] | 955,413 | 955,414 | u094099882 | cpp |
p03160 | #include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (int(i) = (a); (i) < (b); (i)++)
#define REP(i, n) FOR(i, 0, n)
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const long long INF = 1LL << 60;
int main() {
int N;
cin >> N;
vector<int> h;
vector<int> dp;
int tmp;
REP(i, N) {
cin >> tmp;
h.push_back(tmp);
}
REP(i, N) dp.push_back(INF);
dp[0] = 0;
FOR(i, 1, N) {
chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
if (i > 1)
chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
cout << dp[N - 1] << endl;
return 0;
} | #include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (int(i) = (a); (i) < (b); (i)++)
#define REP(i, n) FOR(i, 0, n)
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const long long INF = 1LL << 60;
int main() {
int N;
cin >> N;
vector<int> h;
vector<long long> dp;
int tmp;
REP(i, N) {
cin >> tmp;
h.push_back(tmp);
}
REP(i, N) dp.push_back(INF);
dp[0] = 0;
FOR(i, 1, N) {
chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
if (i > 1)
chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
cout << dp[N - 1] << endl;
return 0;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 955,421 | 955,422 | u145078207 | cpp |
p03160 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <iostream>
#include <limits>
#include <queue>
#include <stack>
#include <tuple>
#include <vector>
using namespace std;
#define INF 1100000000000
#define MAX 100000
#define MOD 100000
typedef long long ll;
typedef pair<int, int> P;
typedef pair<pair<int, int>, int> p;
typedef pair<pair<int, int>, int> p;
#define bit(n, k) ((n >> k) & 1) /*nのk bit目*/
#define rad_to_deg(rad) (((rad) / 2 / M_PI) * 360)
ll dp[110000];
int main() {
int N, h[110000];
cin >> N;
for (int i = 0; i < N; i++) {
cin >> h[i];
}
dp[1] = abs(h[1] - h[0]);
for (int i = 1; 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] << endl;
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <iostream>
#include <limits>
#include <queue>
#include <stack>
#include <tuple>
#include <vector>
using namespace std;
#define INF 1100000000000
#define MAX 100000
#define MOD 100000
typedef long long ll;
typedef pair<int, int> P;
typedef pair<pair<int, int>, int> p;
typedef pair<pair<int, int>, int> p;
#define bit(n, k) ((n >> k) & 1) /*nのk bit目*/
#define rad_to_deg(rad) (((rad) / 2 / M_PI) * 360)
ll dp[110000];
int main() {
int N, h[110000];
cin >> N;
for (int i = 0; i < N; i++) {
cin >> h[i];
}
dp[1] = abs(h[1] - h[0]);
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] << endl;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 955,429 | 955,430 | u591914971 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int wq[100003], st[100003];
int mic(int g) {
if (g <= 0)
return 0;
if (st[g] == 1e9)
return st[g];
st[g] = mic(g - 1) + abs(wq[g] - wq[g - 1]);
if (g > 1)
st[g] = min(st[g], mic(g - 2) + abs(wq[g] - wq[g - 2]));
return st[g];
}
int main() {
int g, t;
scanf("%d", &t);
for (g = 0; g < t; g++)
scanf("%d", &wq[g]), st[g] = 1e9;
mic(t - 1);
printf("%d\n", st[t - 1]);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int wq[100003], st[100003];
int mic(int g) {
if (g <= 0)
return 0;
if (st[g] != 1e9)
return st[g];
st[g] = mic(g - 1) + abs(wq[g] - wq[g - 1]);
if (g > 1)
st[g] = min(st[g], mic(g - 2) + abs(wq[g] - wq[g - 2]));
return st[g];
}
int main() {
int g, t;
scanf("%d", &t);
for (g = 0; g < t; g++)
scanf("%d", &wq[g]), st[g] = 1e9;
mic(t - 1);
printf("%d\n", st[t - 1]);
return 0;
}
| [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 955,431 | 955,432 | u648333443 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
// FILE *fi=freopen("1.txt","r",stdin);
int n, a[100001], d[100005];
void nhap() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
d[i] = 100001;
}
}
void process() {
d[1] = 0;
for (int i = 1; i <= n; ++i) {
d[i + 1] = min(d[i + 1], d[i] + abs(a[i + 1] - a[i]));
d[i + 2] = min(d[i + 2], d[i] + abs(a[i + 2] - a[i]));
}
cout << d[n];
}
int main() {
nhap();
process();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
// FILE *fi=freopen("1.txt","r",stdin);
int n, a[100001], d[200001];
void nhap() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
d[i] = INT_MAX;
}
}
void process() {
d[1] = 0;
for (int i = 1; i <= n; ++i) {
d[i + 1] = min(d[i + 1], d[i] + abs(a[i + 1] - a[i]));
d[i + 2] = min(d[i + 2], d[i] + abs(a[i + 2] - a[i]));
}
cout << d[n];
}
int main() {
nhap();
process();
return 0;
}
| [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 955,435 | 955,436 | u033498359 | cpp |
p03160 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
int h[100010];
for (int i = 1; i <= n; i++) {
cin >> h[i];
}
h[0] = h[1];
int dp[100010];
dp[0] = 0;
dp[1] = 0;
for (int i = 2; i <= n; i++) {
dp[i] = min(dp[i - 2] + max(h[i - 2] - h[i], h[i] - h[i - 2]),
dp[i - 1] + max(h[i - 2] - h[i], h[i] - h[i - 1]));
}
cout << dp[n] << endl;
} | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
int h[100010];
for (int i = 1; i <= n; i++) {
cin >> h[i];
}
h[0] = h[1];
int dp[100010];
dp[0] = 0;
dp[1] = 0;
for (int i = 2; i <= n; i++) {
dp[i] = min(dp[i - 2] + max(h[i - 2] - h[i], h[i] - h[i - 2]),
dp[i - 1] + max(h[i - 1] - h[i], h[i] - h[i - 1]));
}
cout << dp[n] << endl;
} | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 955,437 | 955,438 | u878660242 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int arr[1000005];
int dp[1000005];
int N;
int dpa(int curN) {
// int mal = abs(arr[lInd]-arr[curN]);
if (curN <= 1)
return 0;
if (curN == 2)
return abs(arr[1] - arr[0]);
if (dp[curN] != -1)
return dp[curN];
return dp[curN] = min(dpa(curN - 1) + abs(arr[curN] - arr[curN - 1]),
dpa(curN - 2) + abs(arr[curN] - arr[curN - 2]));
}
// if(dp[curN]!=-1) dp[curN]=min(dp[curN],dp[lInd]+mal);
// else { dpa(curN-1,curN);
// dpa(curN-2,curN);}
//
int main() {
int aN = N - 1;
memset(dp, -1, sizeof(dp));
scanf("%d", &N);
// cout<<N<<"asd\n";
for (size_t i = 0; i < N; i++) {
// cout<<N<<"as43d\n";
cin >> arr[i + 1];
// cout<<endl<<arr[i];
}
int mal = 0;
int curN = 1;
cout << dpa(N) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int arr[1000005];
int dp[1000005];
int N;
int dpa(int curN) {
// int mal = abs(arr[lInd]-arr[curN]);
if (curN <= 1)
return 0;
if (curN == 2)
return abs(arr[2] - arr[1]);
if (dp[curN] != -1)
return dp[curN];
return dp[curN] = min(dpa(curN - 1) + abs(arr[curN] - arr[curN - 1]),
dpa(curN - 2) + abs(arr[curN] - arr[curN - 2]));
}
// if(dp[curN]!=-1) dp[curN]=min(dp[curN],dp[lInd]+mal);
// else { dpa(curN-1,curN);
// dpa(curN-2,curN);}
//
int main() {
int aN = N - 1;
memset(dp, -1, sizeof(dp));
scanf("%d", &N);
// cout<<N<<"asd\n";
for (size_t i = 0; i < N; i++) {
// cout<<N<<"as43d\n";
cin >> arr[i + 1];
// cout<<endl<<arr[i];
}
int mal = 0;
int curN = 1;
cout << dpa(N) << endl;
return 0;
}
| [
"literal.number.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 955,441 | 955,442 | u258931378 | cpp |
p03160 | #include <bits/stdc++.h>
#define ll long long int
using namespace std;
int findans(vector<int> &arr, int n, vector<int> &dp) {
if (n <= 0)
return 0;
if (n == 0)
return arr[n];
if (dp[n + 1] == -1) {
int val = min(abs(arr[n] - arr[n - 1]) + findans(arr, n - 1, dp),
abs(arr[n] - arr[n - 2]) + findans(arr, n - 2, dp));
dp[n + 1] = val;
}
return dp[n + 1];
}
int main() {
int n;
cin >> n;
vector<int> vec(n + 1);
for (int i = 0; i < n; i++) {
cin >> vec[i];
}
vector<int> dp(n, -1);
dp[0] = vec[0];
dp[1] = abs(vec[1] - vec[0]);
for (int i = 2; i < n; i++) {
dp[i] = min(abs(vec[i] - vec[i - 1]) + dp[i - 1],
abs(vec[i] - vec[i - 2]) + dp[i - 2]);
}
// int ans = findans(vec,n-1, dp);
// for(int i=0;i<n;i++)
// cout << dp[i] << " ";
// cout << endl;
cout << dp[n - 1] << endl;
return 0;
} | #include <bits/stdc++.h>
#define ll long long int
using namespace std;
int findans(vector<int> &arr, int n, vector<int> &dp) {
if (n <= 0)
return 0;
if (n == 0)
return arr[n];
if (dp[n + 1] == -1) {
int val = min(abs(arr[n] - arr[n - 1]) + findans(arr, n - 1, dp),
abs(arr[n] - arr[n - 2]) + findans(arr, n - 2, dp));
dp[n + 1] = val;
}
return dp[n + 1];
}
int main() {
int n;
cin >> n;
vector<int> vec(n + 1);
for (int i = 0; i < n; i++) {
cin >> vec[i];
}
vector<int> dp(n, -1);
dp[0] = 0;
dp[1] = abs(vec[1] - vec[0]);
for (int i = 2; i < n; i++) {
dp[i] = min(abs(vec[i] - vec[i - 1]) + dp[i - 1],
abs(vec[i] - vec[i - 2]) + dp[i - 2]);
}
// int ans = findans(vec,n-1, dp);
// for(int i=0;i<n;i++)
// cout << dp[i] << " ";
// cout << endl;
cout << dp[n - 1] << endl;
return 0;
} | [] | 955,443 | 955,444 | u700052359 | cpp |
p03160 | #include <cstring>
#include <iostream>
#include <math.h>
using namespace std;
int a[100001], dp[100001], n;
int solve(int i, int sum) {
if (dp[i] != -1) {
return dp[i];
}
if (i == n - 1) {
return sum;
}
if (i == n - 2) {
return abs(a[i] - a[i + 1]);
}
return dp[i] = min(solve(i + 1, abs(a[i] - a[i + 1])) + abs(a[i] - a[i + 1]),
solve(i + 2, abs(a[i] - a[i + 2])) + abs(a[i] - a[i + 2]));
}
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
dp[i] = -1;
}
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
cout << solve(0, 0);
return 0;
} | #include <cstring>
#include <iostream>
#include <math.h>
using namespace std;
int a[100001], dp[100001], n;
int solve(int i, int sum) {
if (dp[i] != -1) {
return dp[i];
}
if (i == n - 1) {
return 0;
}
if (i == n - 2) {
return abs(a[i] - a[i + 1]);
}
return dp[i] = min(solve(i + 1, abs(a[i] - a[i + 1])) + abs(a[i] - a[i + 1]),
solve(i + 2, abs(a[i] - a[i + 2])) + abs(a[i] - a[i + 2]));
}
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
dp[i] = -1;
}
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
cout << solve(0, 0);
return 0;
} | [
"identifier.replace.remove",
"literal.replace.add",
"function.return_value.change"
] | 955,457 | 955,458 | u491569207 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, a) for (int i = 0; i < (a); i++)
#define ALL(a) (a).begin(), (a).end()
typedef long long ll;
typedef pair<int, int> P;
const ll INF = 1e9;
const int MOD = 1e9 + 7;
int N;
ll h[100001];
ll dp[100001];
ll rec(int n) {
if (dp[n] != -1) {
return dp[n];
}
if (n <= 0) {
return 0;
}
ll res = INF;
res = min(res, rec(n - 1) + abs(h[n] - h[n - 1]));
if (n >= 1) {
res = min(res, rec(n - 2) + abs(h[n] - h[n - 2]));
}
return dp[n] = res;
}
signed main() {
cin >> N;
REP(i, N) { cin >> h[i]; }
memset(dp, -1, sizeof(dp));
cout << rec(N - 1) << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define REP(i, a) for (int i = 0; i < (a); i++)
#define ALL(a) (a).begin(), (a).end()
typedef long long ll;
typedef pair<int, int> P;
const ll INF = 1e12;
const int MOD = 1e9 + 7;
int N;
ll h[100001];
ll dp[100001];
ll rec(int n) {
if (dp[n] != -1) {
return dp[n];
}
if (n == 0) {
return 0;
}
ll res = INF;
res = min(res, rec(n - 1) + abs(h[n] - h[n - 1]));
if (n > 1) {
res = min(res, rec(n - 2) + abs(h[n] - h[n - 2]));
}
return dp[n] = res;
}
signed main() {
cin >> N;
REP(i, N) { cin >> h[i]; }
memset(dp, -1, sizeof(dp));
cout << rec(N - 1) << endl;
} | [
"literal.number.change",
"variable_declaration.value.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 955,469 | 955,470 | u366398972 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define M 100000
int N, v[M], dp[M];
inline int sol(int ind) {
if (ind >= N)
return 0;
if (dp[ind] != -1)
return dp[ind];
return dp[ind] = min(abs(v[ind] - v[ind + 1]) + sol(ind + 1),
abs(v[ind] - v[ind + 2]) + sol(ind + 2));
}
int main() {
cin >> N;
for (int i = 0; i < N; i++)
cin >> v[i];
for (int i = 0; i < M; i++)
dp[i] = -1;
dp[N - 1] = 0;
cout << sol(0);
} | #include <bits/stdc++.h>
using namespace std;
#define M 100000
int N, v[M], dp[M];
inline int sol(int ind) {
if (ind >= N)
return 1e6;
if (dp[ind] != -1)
return dp[ind];
return dp[ind] = min(abs(v[ind] - v[ind + 1]) + sol(ind + 1),
abs(v[ind] - v[ind + 2]) + sol(ind + 2));
}
int main() {
cin >> N;
for (int i = 0; i < N; i++)
cin >> v[i];
for (int i = 0; i < M; i++)
dp[i] = -1;
dp[N - 1] = 0;
cout << sol(0);
} | [
"literal.number.change",
"function.return_value.change"
] | 955,471 | 955,472 | u751943287 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int min(int a, int b) { return a < b ? a : b; }
int main() {
int n;
cin >> n;
int dp[n], val[n];
for (int i = 0; i < n; i++) {
cin >> val[i];
}
for (int i = 0; i < n; ++i) {
if (i == 0) {
dp[0] = 0;
// printf("%d ",dp[i] );
} else if (i == 1) {
dp[1] = val[1] - val[0];
// printf("%d ",dp[i] );
} else {
dp[i] = min((dp[i - 2] + abs(val[i] - val[i - 2])),
(dp[i - 1] + abs(val[i] - val[i - 1])));
// printf("%d ",dp[i] );
}
}
printf("%d\n", dp[n - 1]);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int min(int a, int b) { return a < b ? a : b; }
int main() {
int n;
cin >> n;
int dp[n], val[n];
for (int i = 0; i < n; i++) {
cin >> val[i];
}
for (int i = 0; i < n; ++i) {
if (i == 0) {
dp[0] = 0;
// printf("%d ",dp[i] );
} else if (i == 1) {
dp[1] = abs(val[1] - val[0]);
// printf("%d ",dp[i] );
} else {
dp[i] = min((dp[i - 2] + abs(val[i] - val[i - 2])),
(dp[i - 1] + abs(val[i] - val[i - 1])));
// printf("%d ",dp[i] );
}
}
printf("%d\n", dp[n - 1]);
return 0;
} | [
"call.add",
"call.arguments.change"
] | 955,473 | 955,474 | u094731512 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using db = double;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
#define che(a, string) cout << "//" << string << "==" << (a) << "//" << endl;
#define SORT(a) sort((a).begin(), (a).end())
#define rSORT(a) reverse((a).begin(), (a).end())
#define For(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) For(i, 0, n)
#define leftunique(v) \
SORT(v); \
(v).erase(unique((v).begin(), (v).end()), (v).end())
// leftuniqueは配列から同じ要素のものを取り除く 例 4 6 2 1 3 4 1 2 なら 1 2 3 4
// 6 になる
bool IsInt(double a) {
int b = a / 1;
if (a == b) {
return true;
} else {
return false;
}
}
bool coY() { cout << "Yes" << endl; }
bool coN() { cout << "No" << endl; }
const int mod = 1e9 + 7;
const int INF = 1LL << 60;
int n;
ll h[100010];
ll dp[100010];
ll ans;
//ここから書き始める
int main() {
cout << setprecision(10);
int n;
cin >> n;
vector<ll> h(n);
rep(i, n) cin >> h[i];
rep(i, 100010) dp[i] = INF;
dp[0] = 0;
for (int i = 1; i < n; i++) {
chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
if (i > 1) {
chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
}
cout << dp[n - 1] << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using db = double;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
#define che(a, string) cout << "//" << string << "==" << (a) << "//" << endl;
#define SORT(a) sort((a).begin(), (a).end())
#define rSORT(a) reverse((a).begin(), (a).end())
#define For(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) For(i, 0, n)
#define leftunique(v) \
SORT(v); \
(v).erase(unique((v).begin(), (v).end()), (v).end())
// leftuniqueは配列から同じ要素のものを取り除く 例 4 6 2 1 3 4 1 2 なら 1 2 3 4
// 6 になる
bool IsInt(double a) {
int b = a / 1;
if (a == b) {
return true;
} else {
return false;
}
}
bool coY() { cout << "Yes" << endl; }
bool coN() { cout << "No" << endl; }
const int mod = 1e9 + 7;
const ll INF = 1LL << 60;
int n;
ll h[100010];
ll dp[100010];
ll ans;
//ここから書き始める
int main() {
cout << setprecision(10);
int n;
cin >> n;
vector<ll> h(n);
rep(i, n) cin >> h[i];
rep(i, 100010) dp[i] = INF;
dp[0] = 0;
for (int i = 1; i < n; i++) {
chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
if (i > 1) {
chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
}
cout << dp[n - 1] << endl;
}
| [
"variable_declaration.type.change"
] | 955,475 | 955,476 | u298620933 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll n;
cin >> n;
ll a[n];
for (ll i = 0; i < n; i++)
cin >> a[i];
ll b[n];
b[0] = 0;
b[1] = a[1] - a[0];
if (b[1] < 0)
b[1] = -b[1];
for (ll i = 2; i < n; i++) {
ll c, d;
c = a[i] - a[i - 1];
d = a[i] - a[i - 2];
if (c < 0)
c = -c;
if (d < 0)
d = -d;
if (b[i - 1] + c < b[i - 2])
b[i] = b[i - 1] + c;
else
b[i] = b[i - 2] + d;
}
cout << b[n - 1] << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll n;
cin >> n;
ll a[n];
for (ll i = 0; i < n; i++)
cin >> a[i];
ll b[n];
b[0] = 0;
b[1] = a[1] - a[0];
if (b[1] < 0)
b[1] = -b[1];
for (ll i = 2; i < n; i++) {
ll c, d;
c = a[i] - a[i - 1];
d = a[i] - a[i - 2];
if (c < 0)
c = -c;
if (d < 0)
d = -d;
if (b[i - 1] + c < b[i - 2] + d)
b[i] = b[i - 1] + c;
else
b[i] = b[i - 2] + d;
}
cout << b[n - 1] << endl;
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 955,483 | 955,484 | u330689597 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll n;
cin >> n;
ll a[n];
for (ll i = 0; i < n; i++)
cin >> a[i];
ll b[n];
b[0] = 0;
b[1] = a[1] - a[0];
if (b[1] < 0)
b[1] = -b[1];
for (ll i = 2; i < n; i++) {
ll c, d;
c = a[i] - a[i - 1];
d = a[i] - a[i - 2];
if (c < 0)
c = -c;
if (d < 0)
d = -d;
if (b[i - 1] + c > b[i - 2])
b[i] = b[i - 1] + c;
else
b[i] = b[i - 2] + d;
}
cout << b[n - 1] << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll n;
cin >> n;
ll a[n];
for (ll i = 0; i < n; i++)
cin >> a[i];
ll b[n];
b[0] = 0;
b[1] = a[1] - a[0];
if (b[1] < 0)
b[1] = -b[1];
for (ll i = 2; i < n; i++) {
ll c, d;
c = a[i] - a[i - 1];
d = a[i] - a[i - 2];
if (c < 0)
c = -c;
if (d < 0)
d = -d;
if (b[i - 1] + c < b[i - 2] + d)
b[i] = b[i - 1] + c;
else
b[i] = b[i - 2] + d;
}
cout << b[n - 1] << endl;
}
| [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 955,485 | 955,484 | u330689597 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("03")
#pragma GCC optimize("unroll-loops")
#define ll long long
#define ms(a) memset(a, 0, sizeof(a))
#define endl '\n'
#define pb push_back
#define mp(a, b) make_pair(a, b)
#define mpp(a, b, c) make_pair(a, make_pair(b, c))
#define fi first
#define se second
#define rep(a, b, c) for (int a = b; a <= c; a++)
#define repp(a, b, c) for (int a = b; a >= c; a--)
ll n, arr[100100] = {0};
ll memo[100100] = {0};
ll dp(ll a) {
if (a > n)
return 1e9;
else if (a == n)
return 0;
else if (memo[a])
return memo[a];
else {
ll temp;
temp = min(dp(a + 1) + abs(arr[a] - arr[a + 1]),
dp(a + 2) + abs(arr[a] - arr[a + 2]));
return memo[a] = temp;
}
}
int main() {
/////////////////////////////////////////////
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
/////////////////////////////////////////////
memset(memo, -1, sizeof(memo));
scanf("%lld", &n);
rep(i, 1, n) scanf("%lld", &arr[i]);
ll res;
res = dp(1);
cout << res << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("03")
#pragma GCC optimize("unroll-loops")
#define ll long long
#define ms(a) memset(a, 0, sizeof(a))
#define endl '\n'
#define pb push_back
#define mp(a, b) make_pair(a, b)
#define mpp(a, b, c) make_pair(a, make_pair(b, c))
#define fi first
#define se second
#define rep(a, b, c) for (int a = b; a <= c; a++)
#define repp(a, b, c) for (int a = b; a >= c; a--)
ll n, arr[100100] = {0};
ll memo[100100] = {0};
ll dp(ll a) {
if (a > n)
return 1e9;
else if (a == n)
return 0;
else if (memo[a] != -1)
return memo[a];
else {
ll temp;
temp = min(dp(a + 1) + abs(arr[a] - arr[a + 1]),
dp(a + 2) + abs(arr[a] - arr[a + 2]));
return memo[a] = temp;
}
}
int main() {
/////////////////////////////////////////////
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
/////////////////////////////////////////////
memset(memo, -1, sizeof(memo));
scanf("%lld", &n);
rep(i, 1, n) scanf("%lld", &arr[i]);
ll res;
res = dp(1);
cout << res << endl;
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 955,494 | 955,495 | u481284462 | cpp |
p03160 | // in the name of god
// if you read this code please search about imam hussain
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define pb push_back
#define endl "\n";
#define migmig \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define read \
freopen("input.txt", "r", stdin); \
freopen("output.txt", "w", stdout);
const int maxn = 1e5 + 5;
const int mod = 1e9 + 7;
const int inf = 1e9;
const int del = 728729;
int arr[maxn];
int dp[maxn];
int main() {
migmig;
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
dp[1] = arr[1];
dp[2] = abs(arr[2] - arr[1]);
for (int i = 3; i <= n; i++) {
dp[i] = min(dp[i - 1] + abs(arr[i] - arr[i - 1]),
dp[i - 2] + abs(arr[i] - arr[i - 2]));
}
cout << dp[n];
return 0;
}
| // in the name of god
// if you read this code please search about imam hussain
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define pb push_back
#define endl "\n";
#define migmig \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define read \
freopen("input.txt", "r", stdin); \
freopen("output.txt", "w", stdout);
const int maxn = 1e5 + 5;
const int mod = 1e9 + 7;
const int inf = 1e9;
const int del = 728729;
int arr[maxn];
int dp[maxn];
int main() {
migmig;
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
dp[1] = 0;
dp[2] = abs(arr[2] - arr[1]);
for (int i = 3; i <= n; i++) {
dp[i] = min(dp[i - 1] + abs(arr[i] - arr[i - 1]),
dp[i - 2] + abs(arr[i] - arr[i - 2]));
}
cout << dp[n];
return 0;
}
| [
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add"
] | 955,505 | 955,506 | u433132072 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int dp[N];
int h[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d", &h[i]), dp[i] = 1 << 30;
dp[1] = 0;
for (int i = 2; i <= n; i++) {
if (i - 1 >= 0)
dp[i] = min(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
if (i - 2 >= 0)
dp[i] = min(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
printf("%d\n", dp[n]);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int dp[N];
int h[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d", &h[i]), dp[i] = 1 << 30;
dp[1] = 0;
for (int i = 2; i <= n; i++) {
if (i - 1 > 0)
dp[i] = min(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
if (i - 2 > 0)
dp[i] = min(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
printf("%d\n", dp[n]);
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 955,507 | 955,508 | u377964143 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int dp[N];
int h[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d", &h[i]), dp[i] = 1e9;
dp[1] = 0;
for (int i = 2; i <= n; i++) {
if (i - 1 >= 0)
dp[i] = min(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
if (i - 2 >= 0)
dp[i] = min(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
printf("%d\n", dp[n]);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int dp[N];
int h[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d", &h[i]), dp[i] = 1 << 30;
dp[1] = 0;
for (int i = 2; i <= n; i++) {
if (i - 1 > 0)
dp[i] = min(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
if (i - 2 > 0)
dp[i] = min(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
printf("%d\n", dp[n]);
return 0;
}
| [
"literal.number.change",
"assignment.value.change",
"assignment.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 955,509 | 955,508 | u377964143 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int h[100005];
int n;
int dp[100005];
int solve(int i) {
if (i >= n - 1)
return 0;
if (dp[i] != -1) {
return dp[i];
}
int a = 1e9 + 7, b = 1e9 + 7;
a = solve(i + 1) + abs(h[i] - h[i + 1]);
if (i < n + 2) {
b = solve(i + 2) + abs(h[i] - h[i + 2]);
}
return dp[i] = min(a, b);
}
int main() {
cin >> n;
memset(dp, -1, sizeof(dp));
for (int i = 0; i < n; i++) {
cin >> h[i];
}
cout << solve(0) << endl;
} | #include <bits/stdc++.h>
using namespace std;
int h[100005];
int n;
int dp[100005];
int solve(int i) {
if (i >= n - 1)
return 0;
if (dp[i] != -1) {
return dp[i];
}
int a = 1e9 + 7;
int b = 1e9 + 7;
a = solve(i + 1) + abs(h[i] - h[i + 1]);
if (i < n - 2) {
b = solve(i + 2) + abs(h[i] - h[i + 2]);
}
return dp[i] = min(a, b);
}
int main() {
cin >> n;
memset(dp, -1, sizeof(dp));
for (int i = 0; i < n; i++) {
cin >> h[i];
}
cout << solve(0) << endl;
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change"
] | 955,510 | 955,511 | u667337429 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
const int INF = 1e9;
int n;
cin >> n;
vector<int> h(n);
REP(i, n) cin >> h[i];
vector<int> dp(n, INF);
dp[0] = 0;
for (int i = 1; i < n; i++) {
int cost1 = abs(h[i] - h[i - 1]);
dp[i] = min(dp[i], dp[i - 1] + cost1);
if (i > 2) {
int cost2 = abs(h[i] - h[i - 2]);
dp[i] = min(dp[i], dp[i - 2] + cost2);
}
}
cout << dp[n - 1] << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
const int INF = 1e9;
int n;
cin >> n;
vector<int> h(n);
REP(i, n) cin >> h[i];
vector<int> dp(n, INF);
dp[0] = 0;
for (int i = 1; i < n; i++) {
int cost1 = abs(h[i] - h[i - 1]);
dp[i] = min(dp[i], dp[i - 1] + cost1);
if (i > 1) {
int cost2 = abs(h[i] - h[i - 2]);
dp[i] = min(dp[i], dp[i - 2] + cost2);
}
}
cout << dp[n - 1] << endl;
}
| [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 955,512 | 955,513 | u590000849 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int gcd(long long a, long long b) {
long long M = max(a, b), m = min(a, b);
while (m != 0) {
long long r = M % m;
M = m;
m = r;
}
return M;
}
int digit_sum(long long n) {
long long ans;
while (n != 0) {
ans += n % 10;
n /= 10;
}
return ans;
}
int main() {
int n;
cin >> n;
vector<int> h(n);
for (int i = 0; i < n; i++) {
cin >> h.at(i);
}
vector<int> dp(n);
dp.at(0) = 0;
dp.at(1) = abs(h.at(1) - h.at(0));
if (n >= 3) {
for (int i = 2; i < n; i++) {
dp.at(i) = min(dp.at(i - 1) + abs(h.at(i) - h.at(i - 1)),
dp.at(i - 1) + abs(h.at(i) - h.at(i - 2)));
}
}
cout << dp.at(n - 1) << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int gcd(long long a, long long b) {
long long M = max(a, b), m = min(a, b);
while (m != 0) {
long long r = M % m;
M = m;
m = r;
}
return M;
}
int digit_sum(long long n) {
long long ans;
while (n != 0) {
ans += n % 10;
n /= 10;
}
return ans;
}
int main() {
int n;
cin >> n;
vector<int> h(n);
for (int i = 0; i < n; i++) {
cin >> h.at(i);
}
vector<int> dp(n);
dp.at(0) = 0;
dp.at(1) = abs(h.at(1) - h.at(0));
if (n >= 3) {
for (int i = 2; i < n; i++) {
dp.at(i) = min(dp.at(i - 1) + abs(h.at(i) - h.at(i - 1)),
dp.at(i - 2) + abs(h.at(i) - h.at(i - 2)));
}
}
cout << dp.at(n - 1) << endl;
}
| [
"literal.number.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 955,516 | 955,517 | u522993719 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
void print(vector<int> v) {
for (const auto &i : v)
cout << i << " ";
cout << "\n";
}
const int INF = 1e9 + 5;
int main(int argc, char **argv) {
int n;
cin >> n;
vector<int> s(n);
vector<int> dp(n, 999);
dp[0] = 0;
for (int i = 0; i < n; ++i) {
cin >> s[i];
}
for (int i = 0; i < dp.size(); ++i) {
for (int j : {i + 1, i + 2}) {
if (j < n)
dp[j] = min(abs(s[i] - s[j]) + dp[i], dp[j]);
}
}
printf("%d\n", dp[n - 1]);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
void print(vector<int> v) {
for (const auto &i : v)
cout << i << " ";
cout << "\n";
}
const int INF = 1e9 + 5;
int main(int argc, char **argv) {
int n;
cin >> n;
vector<int> s(n);
vector<int> dp(n, INF);
dp[0] = 0;
for (int i = 0; i < n; ++i) {
cin >> s[i];
}
for (int i = 0; i < dp.size(); ++i) {
for (int j : {i + 1, i + 2}) {
if (j < n)
dp[j] = min(abs(s[i] - s[j]) + dp[i], dp[j]);
}
}
printf("%d\n", dp[n - 1]);
return 0;
} | [
"call.arguments.change"
] | 955,522 | 955,523 | u709540959 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
void print(vector<int> v) {
for (const auto &i : v)
cout << i << " ";
cout << "\n";
}
const int INF = 1e9 + 5;
int main(int argc, char **argv) {
int n;
cin >> n;
vector<int> s(n);
vector<int> dp(n, 999);
dp[0] = 0;
for (int i = 0; i < n; ++i) {
cin >> s[i];
}
for (int i = 0; i < dp.size(); ++i) {
for (int j : {i + 1, i + 2}) {
if (j < n)
dp[j] = min(abs(s[i] - s[j]) + dp[i], dp[j]);
}
}
printf("%d\b", dp[n - 1]);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
void print(vector<int> v) {
for (const auto &i : v)
cout << i << " ";
cout << "\n";
}
const int INF = 1e9 + 5;
int main(int argc, char **argv) {
int n;
cin >> n;
vector<int> s(n);
vector<int> dp(n, INF);
dp[0] = 0;
for (int i = 0; i < n; ++i) {
cin >> s[i];
}
for (int i = 0; i < dp.size(); ++i) {
for (int j : {i + 1, i + 2}) {
if (j < n)
dp[j] = min(abs(s[i] - s[j]) + dp[i], dp[j]);
}
}
printf("%d\n", dp[n - 1]);
return 0;
} | [
"call.arguments.change",
"literal.string.change",
"io.output.change",
"io.output.newline.add"
] | 955,524 | 955,523 | u709540959 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const long long inf = 1LL << 60;
long long dp[100010];
int main() {
int n;
int i;
cin >> n;
vector<int> h(n);
for (i = 0; i < n; ++i) {
cin >> h[i];
}
for (i = 0; i < 100010; ++i) {
dp[i] = inf;
}
dp[0] = 0;
for (i = 1; i < n; ++i) {
chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
if (i > 2) {
chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
}
cout << dp[n - 1] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const long long inf = 1LL << 60;
long long dp[100010];
int main() {
int n;
int i;
cin >> n;
vector<int> h(n);
for (i = 0; i < n; ++i) {
cin >> h[i];
}
for (i = 0; i < 100010; ++i) {
dp[i] = inf;
}
dp[0] = 0;
for (i = 1; i < n; ++i) {
chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
if (i > 1) {
chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
}
cout << dp[n - 1] << endl;
return 0;
} | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 955,532 | 955,533 | u144029820 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std; // cont number of ones from 0 to n in binarry
// representation
#define ll long long
int main() {
int n;
cin >> n;
int ar[n];
for (int i = 0; i < n; i++)
cin >> ar[i];
ll dp[n];
dp[0] = 0, dp[1] = abs(ar[0] - ar[1]);
for (int i = 2; i < n; i++) {
int a, b;
a = ar[i - 1] + abs(ar[i - 1] - ar[i]);
b = ar[i - 2] + abs(ar[i - 2] - ar[i]);
dp[i] = min(a, b);
}
cout << dp[n - 1];
return 0;
}
| #include <bits/stdc++.h>
using namespace std; // cont number of ones from 0 to n in binarry
// representation
#define ll long long
int main() {
int n;
cin >> n;
int ar[n];
for (int i = 0; i < n; i++)
cin >> ar[i];
ll dp[n];
dp[0] = 0, dp[1] = abs(ar[0] - ar[1]);
for (int i = 2; i < n; i++) {
int a, b;
a = dp[i - 1] + abs(ar[i - 1] - ar[i]);
b = dp[i - 2] + abs(ar[i - 2] - ar[i]);
dp[i] = min(a, b);
}
cout << dp[n - 1];
return 0;
}
| [
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 955,534 | 955,535 | u959485410 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std; // cont number of ones from 0 to n in binarry
// representation
#define ll long long
int main() {
int n;
cin >> n;
int ar[n];
for (int i = 0; i < n; i++)
cin >> ar[i];
ll dp[n];
dp[0] = 0, dp[1] = abs(ar[0] - ar[1]);
for (int i = 2; i < n; i++) {
int a, b;
a = ar[i - 1] + abs(dp[i - 1] - ar[i]);
b = ar[i - 2] + abs(dp[i - 2] - ar[i]);
dp[i] = min(a, b);
}
cout << dp[n - 1];
return 0;
}
| #include <bits/stdc++.h>
using namespace std; // cont number of ones from 0 to n in binarry
// representation
#define ll long long
int main() {
int n;
cin >> n;
int ar[n];
for (int i = 0; i < n; i++)
cin >> ar[i];
ll dp[n];
dp[0] = 0, dp[1] = abs(ar[0] - ar[1]);
for (int i = 2; i < n; i++) {
int a, b;
a = dp[i - 1] + abs(ar[i - 1] - ar[i]);
b = dp[i - 2] + abs(ar[i - 2] - ar[i]);
dp[i] = min(a, b);
}
cout << dp[n - 1];
return 0;
}
| [
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 955,536 | 955,535 | u959485410 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std; // cont number of ones from 0 to n in binarry
// representation
#define ll long long
int main() {
int n;
cin >> n;
int ar[n];
for (int i = 0; i < n; i++)
cin >> ar[i];
int dp[n];
dp[0] = 0, dp[1] = abs(ar[0] - ar[1]);
for (int i = 2; i < n; i++) {
int a, b;
a = ar[i - 1] + abs(dp[i - 1] - ar[i]);
b = ar[i - 2] + abs(dp[i - 2] - ar[i]);
dp[i] = min(a, b);
}
cout << dp[n - 1];
return 0;
}
| #include <bits/stdc++.h>
using namespace std; // cont number of ones from 0 to n in binarry
// representation
#define ll long long
int main() {
int n;
cin >> n;
int ar[n];
for (int i = 0; i < n; i++)
cin >> ar[i];
ll dp[n];
dp[0] = 0, dp[1] = abs(ar[0] - ar[1]);
for (int i = 2; i < n; i++) {
int a, b;
a = dp[i - 1] + abs(ar[i - 1] - ar[i]);
b = dp[i - 2] + abs(ar[i - 2] - ar[i]);
dp[i] = min(a, b);
}
cout << dp[n - 1];
return 0;
}
| [
"variable_declaration.type.change",
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 955,537 | 955,535 | u959485410 | cpp |
p03160 | #include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
#define all(x) (x).begin(), (x).end()
typedef long long ll;
#define rep(i, n) for (ll i = 0, i##_len = (n); i < i##_len; ++i)
#define REP(i, num, n) for (ll i = num, i##_len = (n); i < i##_len; ++i)
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
#define print(x) cout << (x) << endl;
#define sz(x) int(x.size())
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
const ll LLINF = 1LL << 60;
const int INF = 1 << 29;
const int MOD = 1000000007;
void add(long long &a, long long b) {
a += b;
if (a >= MOD)
a -= MOD;
}
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
ll dp[100100];
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
ll N;
cin >> N;
vector<ll> h(N);
rep(i, N) cin >> h[i];
REP(i, 1, 100100) dp[i] = LLINF;
REP(i, 1, N) {
chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
if (i > 1)
chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
print(dp[N]);
} | #include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
#define all(x) (x).begin(), (x).end()
typedef long long ll;
#define rep(i, n) for (ll i = 0, i##_len = (n); i < i##_len; ++i)
#define REP(i, num, n) for (ll i = num, i##_len = (n); i < i##_len; ++i)
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
#define print(x) cout << (x) << endl;
#define sz(x) int(x.size())
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
const ll LLINF = 1LL << 60;
const int INF = 1 << 29;
const int MOD = 1000000007;
void add(long long &a, long long b) {
a += b;
if (a >= MOD)
a -= MOD;
}
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
ll dp[100100];
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
ll N;
cin >> N;
vector<ll> h(N);
rep(i, N) cin >> h[i];
REP(i, 1, 100100) dp[i] = LLINF;
REP(i, 1, N) {
chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
if (i > 1)
chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
print(dp[N - 1]);
} | [
"expression.operation.binary.add"
] | 955,538 | 955,539 | u135572611 | cpp |
p03160 | #include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
#define all(x) (x).begin(), (x).end()
typedef long long ll;
#define rep(i, n) for (ll i = 0, i##_len = (n); i < i##_len; ++i)
#define REP(i, num, n) for (ll i = num, i##_len = (n); i < i##_len; ++i)
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
#define print(x) cout << (x) << endl;
#define sz(x) int(x.size())
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
const ll LLINF = 1LL << 60;
const int INF = 1 << 29;
const int MOD = 1000000007;
void add(long long &a, long long b) {
a += b;
if (a >= MOD)
a -= MOD;
}
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
ll dp[100100];
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
ll N;
cin >> N;
vector<ll> h(N);
rep(i, N) cin >> h[i];
REP(i, 1, 100100) dp[i] = LLINF;
dp[0] = 0;
rep(i, N - 2) {
chmin(dp[i + 1], dp[i] + abs(h[i + 1] - h[i]));
chmin(dp[i + 2], dp[i] + abs(h[i + 2] - h[i]));
}
print(dp[N - 1]);
} | #include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
#define all(x) (x).begin(), (x).end()
typedef long long ll;
#define rep(i, n) for (ll i = 0, i##_len = (n); i < i##_len; ++i)
#define REP(i, num, n) for (ll i = num, i##_len = (n); i < i##_len; ++i)
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
#define print(x) cout << (x) << endl;
#define sz(x) int(x.size())
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
const ll LLINF = 1LL << 60;
const int INF = 1 << 29;
const int MOD = 1000000007;
void add(long long &a, long long b) {
a += b;
if (a >= MOD)
a -= MOD;
}
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
ll dp[100100];
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
ll N;
cin >> N;
vector<ll> h(N);
rep(i, N) cin >> h[i];
REP(i, 1, 100100) dp[i] = LLINF;
dp[0] = 0;
rep(i, N - 1) {
chmin(dp[i + 1], dp[i] + abs(h[i + 1] - h[i]));
chmin(dp[i + 2], dp[i] + abs(h[i + 2] - h[i]));
}
print(dp[N - 1]);
}
| [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 955,540 | 955,541 | u135572611 | cpp |
p03160 | #include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
#define all(x) (x).begin(), (x).end()
typedef long long ll;
#define rep(i, n) for (ll i = 0, i##_len = (n); i < i##_len; ++i)
#define REP(i, num, n) for (ll i = num, i##_len = (n); i < i##_len; ++i)
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
#define print(x) cout << (x) << endl;
#define sz(x) int(x.size())
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
const ll LLINF = 1LL << 60;
const int INF = 1 << 29;
const int MOD = 1000000007;
void add(long long &a, long long b) {
a += b;
if (a >= MOD)
a -= MOD;
}
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
ll dp[100100];
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
ll N;
cin >> N;
vector<ll> h(N);
rep(i, N) cin >> h[i];
REP(i, 1, 100100) dp[i] = LLINF;
dp[0] = 0;
rep(i, N - 2) {
chmin(dp[i + 1], dp[i] + abs(h[i + 1] - h[i]));
chmin(dp[i + 2], dp[i] + abs(h[i + 2] - h[i]));
}
print(dp[N - 1]);
} | #include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
#define all(x) (x).begin(), (x).end()
typedef long long ll;
#define rep(i, n) for (ll i = 0, i##_len = (n); i < i##_len; ++i)
#define REP(i, num, n) for (ll i = num, i##_len = (n); i < i##_len; ++i)
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
#define print(x) cout << (x) << endl;
#define sz(x) int(x.size())
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
const ll LLINF = 1LL << 60;
const int INF = 1 << 29;
const int MOD = 1000000007;
void add(long long &a, long long b) {
a += b;
if (a >= MOD)
a -= MOD;
}
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
ll dp[100100];
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
ll N;
cin >> N;
vector<ll> h(N);
rep(i, N) cin >> h[i];
REP(i, 1, 100100) dp[i] = LLINF;
dp[0] = 0;
rep(i, N) {
chmin(dp[i + 1], dp[i] + abs(h[i + 1] - h[i]));
chmin(dp[i + 2], dp[i] + abs(h[i + 2] - h[i]));
}
print(dp[N - 1]);
} | [
"expression.operation.binary.remove"
] | 955,540 | 955,542 | u135572611 | cpp |
p03160 | #include <bits/stdc++.h>
#define all(x) (x).begin(), (x).end()
typedef long long ll;
#define rep(i, n) for (ll i = 0, i##_len = (n); i < i##_len; ++i)
#define REP(i, num, n) for (ll i = num, i##_len = (n); i < i##_len; ++i)
#define repprev(i, a, b) for (ll i = b - 1; i >= a; i--)
#define reprev(i, n) repprev(i, 0, n)
using namespace std;
#define sz(x) ((int)(x).size())
#define ZERO(a) memset(a, 0, sizeof(a))
#define MINUS(a) memset(a, 0xff, sizeof(a))
#define MEMSET(v, h) memset((v), h, sizeof(v))
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <class T> int former(const vector<T> &v, T x) {
return upper_bound(v.begin(), v.end(), x) - v.begin() - 1;
}
template <class T> int latter(const vector<T> &v, T x) {
return lower_bound(v.begin(), v.end(), x) - v.begin();
}
#define pb push_back
#define mp make_pair
#define y0 y3487465
#define y1 y8687969
#define j0 j1347829
#define j1 j234892
#define BIT_FLAG_0 (1 << 0) // 0000 0000 0000 0001
#define BIT_FLAG_1 (1 << 1) // 0000 0000 0000 0010
#define BIT_FLAG_2 (1 << 2) // 0000 0000 0000 0100
#define BIT_FLAG_3 (1 << 3) // 0000 0000 0000 1000
#define BIT_FLAG_4 (1 << 4) // 0000 0000 0001 0000
#define BIT_FLAG_5 (1 << 5) // 0000 0000 0010 0000
#define BIT_FLAG_6 (1 << 6) // 0000 0000 0100 0000
#define BIT_FLAG_7 (1 << 7) // 0000 0000 1000 0000
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
const ll LLINF = 1LL << 60;
const int INTINF = 1 << 30;
const int MAX = 510000;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
struct UnionFind {
vector<ll> par; // par[i]:iの親の番号 (例) par[3] = 2 : 3の親が2
UnionFind(ll n) : par(n, -1) {}
void init(ll n) { par.assign(n, -1); }
ll root(ll x) {
if (par[x] < 0)
return x;
else
return par[x] = root(par[x]);
}
bool issame(ll x, ll y) { return root(x) == root(y); }
bool merge(ll x, ll y) {
x = root(x);
y = root(y);
if (x == y)
return false;
if (par[x] > par[y])
swap(x, y); // merge technique
par[x] += par[y];
par[y] = x;
return true;
}
ll size(ll x) { return -par[root(x)]; }
};
template <typename T>
vector<T> dijkstra(int s, vector<vector<pair<int, T>>> &G) {
const T INF = numeric_limits<T>::max();
using P = pair<T, int>;
int n = G.size();
vector<T> d(n, INF);
vector<int> b(n, -1);
priority_queue<P, vector<P>, greater<P>> q;
d[s] = 0;
q.emplace(d[s], s);
while (!q.empty()) {
P p = q.top();
q.pop();
int v = p.second;
if (d[v] < p.first)
continue;
for (auto &e : G[v]) {
int u = e.first;
T c = e.second;
if (d[u] > d[v] + c) {
d[u] = d[v] + c;
b[u] = v;
q.emplace(d[u], u);
}
}
}
return d;
}
vector<vector<int>> bfs(vector<string> &s, int sy, int sx, char wall, int dir) {
int h = s.size(), w = s.front().size();
vector<vector<int>> dp(h, vector<int>(w, -1));
using P = pair<int, int>;
queue<P> q;
dp[sy][sx] = 0;
q.emplace(sy, sx);
int dy[] = {1, -1, 0, 0, 1, 1, -1, -1};
int dx[] = {0, 0, 1, -1, 1, -1, 1, -1};
auto in = [&](int y, int x) { return 0 <= y && y < h && 0 <= x && x < w; };
while (!q.empty()) {
int y, x;
tie(y, x) = q.front();
q.pop();
for (int k = 0; k < dir; k++) {
int ny = y + dy[k], nx = x + dx[k];
if (!in(ny, nx) || s[ny][nx] == wall)
continue;
if (~dp[ny][nx])
continue;
dp[ny][nx] = dp[y][x] + 1;
q.emplace(ny, nx);
}
}
return dp;
}
int64_t power(int64_t x, int64_t n, int64_t mod) {
int64_t ret = 1;
while (n > 0) {
if (n & 1)
(ret *= x) %= mod;
(x *= x) %= mod;
n >>= 1;
}
return ret;
}
vector<int> sieve_of_eratosthenes(int n) {
vector<int> primes(n);
for (int i = 2; i < n; ++i)
primes[i] = i;
for (int i = 2; i * i < n; ++i)
if (primes[i])
for (int j = i * i; j < n; j += i)
primes[j] = 0;
return primes;
}
struct Dice {
int s[6];
int &top() { return s[0]; }
int &south() { return s[1]; }
int &east() { return s[2]; }
int &west() { return s[3]; }
int &north() { return s[4]; }
int &bottom() { return s[5]; }
void roll(char c) {
// the view from above
// N
// W E
// S
string b("EWNSRL");
int v[6][4] = {{0, 3, 5, 2}, {0, 2, 5, 3}, {0, 1, 5, 4},
{0, 4, 5, 1}, {1, 2, 4, 3}, {1, 3, 4, 2}};
for (int k = 0; k < 6; k++) {
if (b[k] != c)
continue;
int t = s[v[k][0]];
s[v[k][0]] = s[v[k][1]];
s[v[k][1]] = s[v[k][2]];
s[v[k][2]] = s[v[k][3]];
s[v[k][3]] = t;
}
}
using ll = long long;
ll hash() {
ll res = 0;
for (int i = 0; i < 6; i++)
res = res * 256 + s[i];
return res;
}
bool operator==(const Dice &d) const {
for (int i = 0; i < 6; i++)
if (s[i] != d.s[i])
return 0;
return 1;
}
};
vector<Dice> makeDices(Dice d) {
vector<Dice> res;
for (int i = 0; i < 6; i++) {
Dice t(d);
if (i == 1)
t.roll('N');
if (i == 2)
t.roll('S');
if (i == 3)
t.roll('S'), t.roll('S');
if (i == 4)
t.roll('L');
if (i == 5)
t.roll('R');
for (int k = 0; k < 4; k++) {
res.push_back(t);
t.roll('E');
}
}
return res;
}
std::vector<ll> divisor(ll n) // nの約数を列挙
{
std::vector<ll> ret;
for (ll i = 1; i * i <= n; ++i) {
if (n % i == 0) {
ret.push_back(i);
if (i != 1 && i * i != n) {
ret.push_back(n / i);
}
}
}
return ret;
}
// 多次元 vector 生成
template <class T> vector<T> make_vec(size_t a) { return vector<T>(a); }
template <class T, class... Ts> auto make_vec(size_t a, Ts... ts) {
return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}
using Graph = vector<vector<int>>;
// 深さ優先探索
vector<bool> seen;
void gdfs(const Graph &G, int v) {
seen[v] = true; // v を訪問済にする
// v から行ける各頂点 next_v について
for (auto next_v : G[v]) {
if (seen[next_v])
continue; // next_v が探索済だったらスルー
gdfs(G, next_v); // 再帰的に探索
}
}
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
const string MINUSINF = "-";
void Cmax(string &a, string b) {
if (a == MINUSINF)
a = b;
else if (a.size() < b.size())
a = b;
else if (a.size() == b.size()) {
if (a < b)
a = b;
}
}
ll dp[100100];
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
ll N;
cin >> N;
vector<ll> h(N);
rep(i, N) cin >> h[i];
dp[0] = 0;
REP(i, 1, 100100) dp[i] = LLINF;
REP(i, 1, N) {
if (i < 2)
dp[i] = dp[i - 1] + abs(h[i] - h[i - 1]);
else
dp[i] = min(dp[i - 2] + abs(h[i] - h[i - 2]),
dp[i - 1] + abs(h[i] - h[i - 1]));
}
cout << dp[N] << endl;
}
| #include <bits/stdc++.h>
#define all(x) (x).begin(), (x).end()
typedef long long ll;
#define rep(i, n) for (ll i = 0, i##_len = (n); i < i##_len; ++i)
#define REP(i, num, n) for (ll i = num, i##_len = (n); i < i##_len; ++i)
#define repprev(i, a, b) for (ll i = b - 1; i >= a; i--)
#define reprev(i, n) repprev(i, 0, n)
using namespace std;
#define sz(x) ((int)(x).size())
#define ZERO(a) memset(a, 0, sizeof(a))
#define MINUS(a) memset(a, 0xff, sizeof(a))
#define MEMSET(v, h) memset((v), h, sizeof(v))
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <class T> int former(const vector<T> &v, T x) {
return upper_bound(v.begin(), v.end(), x) - v.begin() - 1;
}
template <class T> int latter(const vector<T> &v, T x) {
return lower_bound(v.begin(), v.end(), x) - v.begin();
}
#define pb push_back
#define mp make_pair
#define y0 y3487465
#define y1 y8687969
#define j0 j1347829
#define j1 j234892
#define BIT_FLAG_0 (1 << 0) // 0000 0000 0000 0001
#define BIT_FLAG_1 (1 << 1) // 0000 0000 0000 0010
#define BIT_FLAG_2 (1 << 2) // 0000 0000 0000 0100
#define BIT_FLAG_3 (1 << 3) // 0000 0000 0000 1000
#define BIT_FLAG_4 (1 << 4) // 0000 0000 0001 0000
#define BIT_FLAG_5 (1 << 5) // 0000 0000 0010 0000
#define BIT_FLAG_6 (1 << 6) // 0000 0000 0100 0000
#define BIT_FLAG_7 (1 << 7) // 0000 0000 1000 0000
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
const ll LLINF = 1LL << 60;
const int INTINF = 1 << 30;
const int MAX = 510000;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
struct UnionFind {
vector<ll> par; // par[i]:iの親の番号 (例) par[3] = 2 : 3の親が2
UnionFind(ll n) : par(n, -1) {}
void init(ll n) { par.assign(n, -1); }
ll root(ll x) {
if (par[x] < 0)
return x;
else
return par[x] = root(par[x]);
}
bool issame(ll x, ll y) { return root(x) == root(y); }
bool merge(ll x, ll y) {
x = root(x);
y = root(y);
if (x == y)
return false;
if (par[x] > par[y])
swap(x, y); // merge technique
par[x] += par[y];
par[y] = x;
return true;
}
ll size(ll x) { return -par[root(x)]; }
};
template <typename T>
vector<T> dijkstra(int s, vector<vector<pair<int, T>>> &G) {
const T INF = numeric_limits<T>::max();
using P = pair<T, int>;
int n = G.size();
vector<T> d(n, INF);
vector<int> b(n, -1);
priority_queue<P, vector<P>, greater<P>> q;
d[s] = 0;
q.emplace(d[s], s);
while (!q.empty()) {
P p = q.top();
q.pop();
int v = p.second;
if (d[v] < p.first)
continue;
for (auto &e : G[v]) {
int u = e.first;
T c = e.second;
if (d[u] > d[v] + c) {
d[u] = d[v] + c;
b[u] = v;
q.emplace(d[u], u);
}
}
}
return d;
}
vector<vector<int>> bfs(vector<string> &s, int sy, int sx, char wall, int dir) {
int h = s.size(), w = s.front().size();
vector<vector<int>> dp(h, vector<int>(w, -1));
using P = pair<int, int>;
queue<P> q;
dp[sy][sx] = 0;
q.emplace(sy, sx);
int dy[] = {1, -1, 0, 0, 1, 1, -1, -1};
int dx[] = {0, 0, 1, -1, 1, -1, 1, -1};
auto in = [&](int y, int x) { return 0 <= y && y < h && 0 <= x && x < w; };
while (!q.empty()) {
int y, x;
tie(y, x) = q.front();
q.pop();
for (int k = 0; k < dir; k++) {
int ny = y + dy[k], nx = x + dx[k];
if (!in(ny, nx) || s[ny][nx] == wall)
continue;
if (~dp[ny][nx])
continue;
dp[ny][nx] = dp[y][x] + 1;
q.emplace(ny, nx);
}
}
return dp;
}
int64_t power(int64_t x, int64_t n, int64_t mod) {
int64_t ret = 1;
while (n > 0) {
if (n & 1)
(ret *= x) %= mod;
(x *= x) %= mod;
n >>= 1;
}
return ret;
}
vector<int> sieve_of_eratosthenes(int n) {
vector<int> primes(n);
for (int i = 2; i < n; ++i)
primes[i] = i;
for (int i = 2; i * i < n; ++i)
if (primes[i])
for (int j = i * i; j < n; j += i)
primes[j] = 0;
return primes;
}
struct Dice {
int s[6];
int &top() { return s[0]; }
int &south() { return s[1]; }
int &east() { return s[2]; }
int &west() { return s[3]; }
int &north() { return s[4]; }
int &bottom() { return s[5]; }
void roll(char c) {
// the view from above
// N
// W E
// S
string b("EWNSRL");
int v[6][4] = {{0, 3, 5, 2}, {0, 2, 5, 3}, {0, 1, 5, 4},
{0, 4, 5, 1}, {1, 2, 4, 3}, {1, 3, 4, 2}};
for (int k = 0; k < 6; k++) {
if (b[k] != c)
continue;
int t = s[v[k][0]];
s[v[k][0]] = s[v[k][1]];
s[v[k][1]] = s[v[k][2]];
s[v[k][2]] = s[v[k][3]];
s[v[k][3]] = t;
}
}
using ll = long long;
ll hash() {
ll res = 0;
for (int i = 0; i < 6; i++)
res = res * 256 + s[i];
return res;
}
bool operator==(const Dice &d) const {
for (int i = 0; i < 6; i++)
if (s[i] != d.s[i])
return 0;
return 1;
}
};
vector<Dice> makeDices(Dice d) {
vector<Dice> res;
for (int i = 0; i < 6; i++) {
Dice t(d);
if (i == 1)
t.roll('N');
if (i == 2)
t.roll('S');
if (i == 3)
t.roll('S'), t.roll('S');
if (i == 4)
t.roll('L');
if (i == 5)
t.roll('R');
for (int k = 0; k < 4; k++) {
res.push_back(t);
t.roll('E');
}
}
return res;
}
std::vector<ll> divisor(ll n) // nの約数を列挙
{
std::vector<ll> ret;
for (ll i = 1; i * i <= n; ++i) {
if (n % i == 0) {
ret.push_back(i);
if (i != 1 && i * i != n) {
ret.push_back(n / i);
}
}
}
return ret;
}
// 多次元 vector 生成
template <class T> vector<T> make_vec(size_t a) { return vector<T>(a); }
template <class T, class... Ts> auto make_vec(size_t a, Ts... ts) {
return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}
using Graph = vector<vector<int>>;
// 深さ優先探索
vector<bool> seen;
void gdfs(const Graph &G, int v) {
seen[v] = true; // v を訪問済にする
// v から行ける各頂点 next_v について
for (auto next_v : G[v]) {
if (seen[next_v])
continue; // next_v が探索済だったらスルー
gdfs(G, next_v); // 再帰的に探索
}
}
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
const string MINUSINF = "-";
void Cmax(string &a, string b) {
if (a == MINUSINF)
a = b;
else if (a.size() < b.size())
a = b;
else if (a.size() == b.size()) {
if (a < b)
a = b;
}
}
ll dp[100100];
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
ll N;
cin >> N;
vector<ll> h(N);
rep(i, N) cin >> h[i];
dp[0] = 0;
REP(i, 1, 100100) dp[i] = LLINF;
REP(i, 1, N) {
if (i < 2)
dp[i] = dp[i - 1] + abs(h[i] - h[i - 1]);
else
dp[i] = min(dp[i - 2] + abs(h[i] - h[i - 2]),
dp[i - 1] + abs(h[i] - h[i - 1]));
}
cout << dp[N - 1] << endl;
}
| [
"expression.operation.binary.add"
] | 955,545 | 955,546 | u135572611 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define mod 1000000007
#define rep(i, a, b) for (ll i = a; i < b; i++)
#define repc(i, a, b, c) \
for (ll i = a; (c > 0 ? i < b : i > b) and c != 0; i += c)
#define mp make_pair
#define pb push_back
#define all(name) (name.begin(), name.end())
#define fact(n) rep(i, 1, n + 1) ft.pb((ft[i - 1] * i) % mod);
#define mod_in(a) power(a, mod - 2)
#define ncr(n, r) ((ft[n] * mod_in((ft[r] * ft[(n) - (r)]) % mod)) % mod)
#define deb(x) cout << #x << " " << x << endl;
// ll dp[105][100005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
// cin >> t;
while (t--) {
ll n, k;
cin >> n >> k;
ll arr[n];
rep(i, 0, n) cin >> arr[i];
ll dp[n];
dp[0] = 0;
rep(i, 1, n) {
dp[i] = dp[i - 1] + abs(arr[i] - arr[i - 1]);
rep(j, 2, k + 1) if (i - j >= 0) dp[i] =
min(dp[i], dp[i - j] + abs(arr[i] - arr[i - j]));
}
cout << dp[n - 1];
}
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define mod 1000000007
#define rep(i, a, b) for (ll i = a; i < b; i++)
#define repc(i, a, b, c) \
for (ll i = a; (c > 0 ? i < b : i > b) and c != 0; i += c)
#define mp make_pair
#define pb push_back
#define all(name) (name.begin(), name.end())
#define fact(n) rep(i, 1, n + 1) ft.pb((ft[i - 1] * i) % mod);
#define mod_in(a) power(a, mod - 2)
#define ncr(n, r) ((ft[n] * mod_in((ft[r] * ft[(n) - (r)]) % mod)) % mod)
#define deb(x) cout << #x << " " << x << endl;
// ll dp[105][100005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
// cin >> t;
while (t--) {
ll n, k;
cin >> n;
k = 2;
ll arr[n];
rep(i, 0, n) cin >> arr[i];
ll dp[n];
dp[0] = 0;
rep(i, 1, n) {
dp[i] = dp[i - 1] + abs(arr[i] - arr[i - 1]);
rep(j, 2, k + 1) if (i - j >= 0) dp[i] =
min(dp[i], dp[i - j] + abs(arr[i] - arr[i - j]));
}
cout << dp[n - 1];
}
} | [
"expression.operation.binary.remove",
"assignment.add"
] | 955,551 | 955,552 | u202796595 | cpp |
p03160 | #include <iostream>
#include <vector>
using namespace std;
const int INF = 1e9;
vector<int> arr;
vector<int> dp;
int N;
int solve(int x) {
if (x >= N - 1)
return 0;
if (dp[x] != -1)
return dp[x];
int j1 = abs(arr[x] - arr[x + 1]) + solve(x + 1);
int j2 = INF;
if (x < N - 1)
j2 = abs(arr[x] - arr[x + 2]) + solve(x + 2);
return dp[x] = min(j1, j2);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> N;
arr = vector<int>(N);
dp = vector<int>(N, -1);
for (auto &x : arr)
cin >> x;
cout << solve(0) << "\n";
}
| #include <iostream>
#include <vector>
using namespace std;
const int INF = 1e9;
vector<int> arr;
vector<int> dp;
int N;
int solve(int x) {
if (x >= N - 1)
return 0;
if (dp[x] != -1)
return dp[x];
int j1 = abs(arr[x] - arr[x + 1]) + solve(x + 1);
int j2 = INF;
if (x < N - 2)
j2 = abs(arr[x] - arr[x + 2]) + solve(x + 2);
return dp[x] = min(j1, j2);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> N;
arr = vector<int>(N);
dp = vector<int>(N, -1);
for (auto &x : arr)
cin >> x;
cout << solve(0) << "\n";
}
| [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 955,559 | 955,560 | u610908776 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int h[n], dp[n + 2]{0};
for (int i = 1; i <= n; i++)
cin >> h[i];
dp[2] = h[2] - h[1];
for (int i = 3; i <= n; i++) {
dp[i] =
min(dp[i - 1] + abs(h[i] - h[i - 1]), dp[i - 2] + abs(h[i] - h[i - 2]));
}
cout << dp[n];
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int h[n], dp[n + 2]{0};
for (int i = 1; i <= n; i++)
cin >> h[i];
dp[2] = abs(h[2] - h[1]);
for (int i = 3; i <= n; i++) {
dp[i] =
min(dp[i - 1] + abs(h[i] - h[i - 1]), dp[i - 2] + abs(h[i] - h[i - 2]));
}
cout << dp[n];
return 0;
} | [
"call.add",
"call.arguments.change"
] | 955,561 | 955,562 | u253715819 | cpp |
p03160 | #include <algorithm>
#include <iostream>
#define AC ios_base::sync_with_stdio(0), cin.tie(0);
using namespace std;
int main(int argc, char **argv) {
// AC
int limit;
cin >> limit;
int *arr = new int[limit];
int *dp = new int[limit];
for (int i = 0; i < limit; i++)
cin >> arr[i];
dp[0] = arr[0], dp[1] = abs(arr[0] - arr[1]);
for (int i = 2; i < limit; i++)
dp[i] = min(dp[i - 2] + abs(arr[i] - arr[i - 2]),
dp[i - 1] + abs(arr[i] - arr[i - 1]));
cout << dp[limit - 1] << '\n';
return 0;
} | #include <algorithm>
#include <iostream>
#define AC ios_base::sync_with_stdio(0), cin.tie(0);
using namespace std;
int main(int argc, char **argv) {
// AC
int limit;
cin >> limit;
int *arr = new int[limit];
int *dp = new int[limit];
for (int i = 0; i < limit; i++)
cin >> arr[i];
dp[0] = 0, dp[1] = abs(arr[0] - arr[1]);
for (int i = 2; i < limit; i++)
dp[i] = min(dp[i - 2] + abs(arr[i] - arr[i - 2]),
dp[i - 1] + abs(arr[i] - arr[i - 1]));
cout << dp[limit - 1] << '\n';
return 0;
} | [] | 955,569 | 955,570 | u782898395 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int A(int a) {
if (a < 0)
return -a;
return a;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int arr[200000], N;
int DP[200000];
cin >> N;
for (int i = 0; i < N; i++) {
cin >> arr[i];
}
DP[0] = 0;
DP[1] = arr[1] - arr[0];
for (int i = 2; i < N; i++) {
DP[i] = min(DP[i - 1] + A(arr[i] - arr[i - 1]),
DP[i - 2] + A(arr[i] - arr[i - 2]));
}
cout << DP[N - 1] << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int A(int a) {
if (a < 0)
return -a;
return a;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int arr[200000], N;
int DP[200000];
cin >> N;
for (int i = 0; i < N; i++) {
cin >> arr[i];
}
DP[0] = 0;
DP[1] = A(arr[1] - arr[0]);
for (int i = 2; i < N; i++) {
DP[i] = min(DP[i - 1] + A(arr[i] - arr[i - 1]),
DP[i - 2] + A(arr[i] - arr[i - 2]));
}
cout << DP[N - 1] << endl;
}
| [
"call.add",
"call.arguments.change"
] | 955,579 | 955,580 | u933159466 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int arr[1000000];
int dp[1000000];
for (int i = 0; i < N; i++) {
cin >> arr[i];
}
dp[0] = 0;
dp[1] = abs(arr[2] - arr[1]);
for (int i = 2; i < N; i++) {
dp[i] = min(abs(arr[i] - arr[i - 1]) + dp[i - 1],
abs(arr[i] - arr[i - 2]) + dp[i - 2]);
}
cout << dp[N - 1];
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int arr[1000000];
int dp[1000000];
for (int i = 0; i < N; i++) {
cin >> arr[i];
}
dp[0] = 0;
dp[1] = abs(arr[0] - arr[1]);
for (int i = 2; i < N; i++) {
dp[i] = min(abs(arr[i] - arr[i - 1]) + dp[i - 1],
abs(arr[i] - arr[i - 2]) + 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"
] | 955,581 | 955,582 | u537207678 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int arr[N];
int dp[N];
for (int i = 0; i < N; i++) {
cin >> arr[i];
}
dp[0] = 0;
dp[1] = abs(arr[2] - arr[1]);
for (int i = 2; i < N; i++) {
dp[i] = min(abs(arr[i] - arr[i - 1]) + dp[i - 1],
abs(arr[i] - arr[i - 2]) + dp[i - 2]);
}
cout << dp[N - 1];
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int arr[1000000];
int dp[1000000];
for (int i = 0; i < N; i++) {
cin >> arr[i];
}
dp[0] = 0;
dp[1] = abs(arr[0] - arr[1]);
for (int i = 2; i < N; i++) {
dp[i] = min(abs(arr[i] - arr[i - 1]) + dp[i - 1],
abs(arr[i] - arr[i - 2]) + dp[i - 2]);
}
cout << dp[N - 1];
return 0;
} | [
"identifier.replace.remove",
"literal.replace.add",
"variable_declaration.array_dimensions.change",
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 955,583 | 955,582 | u537207678 | cpp |
p03160 | #include <bits/stdc++.h>
#define rep(i, cc, n) for (int i = cc; i <= n; ++i)
#define drep(i, cc, n) for (int i = cc; i >= n; --i)
#define sz(s) (int)(s.size())
#define vecprint(v) \
rep(i, 0, v.size() - 1) cout << v[i] << " "; \
cout << endl;
#define mod 1000000007
using namespace std;
int main() {
int n;
cin >> n;
vector<long long> h(n + 1), cost(n + 1, 1000000);
rep(i, 0, n - 1) cin >> h[i];
h[n] = 0;
cost[0] = 0;
rep(i, 0, n - 2) {
cost[i + 1] = min(cost[i + 1], cost[i] + abs(h[i] - h[i + 1]));
cost[i + 2] = min(cost[i + 2], cost[i] + abs(h[i] - h[i + 2]));
}
int ans = cost[n - 1];
cout << ans << endl;
// printf("%.10f\n",ans);
return 0;
} | #include <bits/stdc++.h>
#define rep(i, cc, n) for (int i = cc; i <= n; ++i)
#define drep(i, cc, n) for (int i = cc; i >= n; --i)
#define sz(s) (int)(s.size())
#define vecprint(v) \
rep(i, 0, v.size() - 1) cout << v[i] << " "; \
cout << endl;
#define mod 1000000007
using namespace std;
int main() {
int n;
cin >> n;
vector<long long> h(n + 1), cost(n + 1, 1000000000);
rep(i, 0, n - 1) cin >> h[i];
h[n] = 1000000000;
cost[0] = 0;
rep(i, 0, n - 2) {
cost[i + 1] = min(cost[i + 1], cost[i] + abs(h[i] - h[i + 1]));
cost[i + 2] = min(cost[i + 2], cost[i] + abs(h[i] - h[i + 2]));
}
int ans = cost[n - 1];
cout << ans << endl;
// printf("%.10f\n",ans);
return 0;
} | [
"literal.number.change",
"call.arguments.change",
"assignment.value.change"
] | 955,584 | 955,585 | u736278528 | cpp |
p03160 | #include <bits/stdc++.h>
#define rep(i, cc, n) for (int i = cc; i <= n; ++i)
#define drep(i, cc, n) for (int i = cc; i >= n; --i)
#define sz(s) (int)(s.size())
#define vecprint(v) \
rep(i, 0, v.size() - 1) cout << v[i] << " "; \
cout << endl;
#define mod 1000000007
using namespace std;
int main() {
int n;
cin >> n;
vector<int> h(n + 1), cost(n + 1, 1000000);
rep(i, 0, n - 1) cin >> h[i];
h[n] = 0;
cost[0] = 0;
rep(i, 0, n - 2) {
cost[i + 1] = min(cost[i + 1], cost[i] + abs(h[i] - h[i + 1]));
cost[i + 2] = min(cost[i + 2], cost[i] + abs(h[i] - h[i + 2]));
}
int ans = cost[n - 1];
cout << ans << endl;
// printf("%.10f\n",ans);
return 0;
} | #include <bits/stdc++.h>
#define rep(i, cc, n) for (int i = cc; i <= n; ++i)
#define drep(i, cc, n) for (int i = cc; i >= n; --i)
#define sz(s) (int)(s.size())
#define vecprint(v) \
rep(i, 0, v.size() - 1) cout << v[i] << " "; \
cout << endl;
#define mod 1000000007
using namespace std;
int main() {
int n;
cin >> n;
vector<long long> h(n + 1), cost(n + 1, 1000000000);
rep(i, 0, n - 1) cin >> h[i];
h[n] = 1000000000;
cost[0] = 0;
rep(i, 0, n - 2) {
cost[i + 1] = min(cost[i + 1], cost[i] + abs(h[i] - h[i + 1]));
cost[i + 2] = min(cost[i + 2], cost[i] + abs(h[i] - h[i + 2]));
}
int ans = cost[n - 1];
cout << ans << endl;
// printf("%.10f\n",ans);
return 0;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"literal.number.change",
"call.arguments.change",
"assignment.value.change"
] | 955,586 | 955,585 | u736278528 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int(i) = 0; (i) < (int)(n); ++(i))
#define REPN(i, m, n) for (int(i) = m; (i) < (int)(n); ++(i))
#define REP_REV(i, n) for (int(i) = (int)(n)-1; (i) >= 0; --(i))
#define REPN_REV(i, m, n) for (int(i) = (int)(n)-1; (i) >= m; --(i))
#define INF 2e9
#define INF_LL 1LL << 60
#define ll long long
#define MOD 1e9 + 7
#define MAX_V
const double PI = 3.14159265358979323846;
#define print2D(h, w, arr) \
REP(i, h) { \
REP(j, w) cout << arr[i][j] << " "; \
cout << endl; \
}
#define print_line(vec, n) \
{ \
for (int i = 0; i < (n - 1); i++) \
cout << (vec)[i] << " "; \
cout << (vec)[(n)-1] << endl; \
}
template <class T> void print(const T &x) { cout << x << endl; }
template <class T, class... A> void print(const T &first, const A &...rest) {
cout << first << " ";
print(rest...);
}
struct PreMain {
PreMain() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
}
} premain;
int main() {
int n;
cin >> n;
vector<int> h(n);
REP(i, n) cin >> h[i];
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] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int(i) = 0; (i) < (int)(n); ++(i))
#define REPN(i, m, n) for (int(i) = m; (i) < (int)(n); ++(i))
#define REP_REV(i, n) for (int(i) = (int)(n)-1; (i) >= 0; --(i))
#define REPN_REV(i, m, n) for (int(i) = (int)(n)-1; (i) >= m; --(i))
#define INF 2e9
#define INF_LL 1LL << 60
#define ll long long
#define MOD 1e9 + 7
#define MAX_V
const double PI = 3.14159265358979323846;
#define print2D(h, w, arr) \
REP(i, h) { \
REP(j, w) cout << arr[i][j] << " "; \
cout << endl; \
}
#define print_line(vec, n) \
{ \
for (int i = 0; i < (n - 1); i++) \
cout << (vec)[i] << " "; \
cout << (vec)[(n)-1] << endl; \
}
template <class T> void print(const T &x) { cout << x << endl; }
template <class T, class... A> void print(const T &first, const A &...rest) {
cout << first << " ";
print(rest...);
}
struct PreMain {
PreMain() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
}
} premain;
int main() {
int n;
cin >> n;
vector<int> h(n);
REP(i, n) cin >> h[i];
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] << endl;
return 0;
} | [
"call.arguments.change"
] | 955,593 | 955,594 | u127768253 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define x first
#define y second
#define ll long long
#define pi pair<int, int>
#define pl pair<ll, ll>
#define pd pair<double, double>
#define ld long double
#define pld pair<ld, ld>
#define lg length()
#define sz size()
#define vi vector<int>
#define vl vector<ll>
#define vp vector<pi>
#define vpl vector<pl>
#define pb push_back
#define INF 1000000005
#define LINF 1000000000000000005
using namespace std;
const int maxn = 1e5 + 100;
int dp[maxn], h[maxn];
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie();
cout.tie();
#ifndef ONLINE_JUDGE
ifstream cin("input.txt");
#endif
int N;
cin >> N;
for (int i = 1; i <= N; i++)
cin >> h[i];
dp[1] = 0;
for (int i = 2; i <= N; i++)
dp[i] = min(dp[i - 1] + abs(h[i] - h[i - 1]),
i == 2 ? INF : dp[i - 2] + abs(h[i] - h[i - 2]));
cout << dp[N] << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
#define x first
#define y second
#define ll long long
#define pi pair<int, int>
#define pl pair<ll, ll>
#define pd pair<double, double>
#define ld long double
#define pld pair<ld, ld>
#define lg length()
#define sz size()
#define vi vector<int>
#define vl vector<ll>
#define vp vector<pi>
#define vpl vector<pl>
#define pb push_back
#define INF 1000000005
#define LINF 1000000000000000005
using namespace std;
const int maxn = 1e5 + 100;
int dp[maxn], h[maxn];
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie();
cout.tie();
#ifdef LOCAL_DEFINE
ifstream cin("input.txt");
#endif
int N;
cin >> N;
for (int i = 1; i <= N; i++)
cin >> h[i];
dp[1] = 0;
for (int i = 2; i <= N; i++)
dp[i] = min(dp[i - 1] + abs(h[i] - h[i - 1]),
i == 2 ? INF : dp[i - 2] + abs(h[i] - h[i - 2]));
cout << dp[N] << "\n";
}
| [] | 955,597 | 955,598 | u663257960 | cpp |
p03160 | #include <iostream>
#include <vector>
using namespace std;
int dp[100050] = {};
int num(int a) {
if (a < 0)
return -a;
else
return a;
}
int min1(int a, int b) {
if (a < b)
return a;
else
return b;
}
int main() {
int n;
cin >> n;
vector<int> h(n + 5);
for (int i = 1; i <= n; i++) {
cin >> h[i];
}
dp[1] = 0;
dp[2] = num(h[1] - h[0]);
for (int i = 3; i <= n; i++) {
dp[i] = min1(dp[i - 1] + num(h[i] - h[i - 1]),
dp[i - 2] + num(h[i] - h[i - 2]));
}
cout << dp[n] << endl;
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
int dp[100050] = {};
int num(int a) {
if (a < 0)
return -a;
else
return a;
}
int min1(int a, int b) {
if (a < b)
return a;
else
return b;
}
int main() {
int n;
cin >> n;
vector<int> h(n + 5);
for (int i = 1; i <= n; i++) {
cin >> h[i];
}
dp[1] = 0;
dp[2] = num(h[2] - h[1]);
for (int i = 3; i <= n; i++) {
dp[i] = min1(dp[i - 1] + num(h[i] - h[i - 1]),
dp[i - 2] + num(h[i] - h[i - 2]));
}
cout << dp[n] << endl;
return 0;
} | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 955,599 | 955,600 | u313043608 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ar[n];
for (int i = 0; i < n; ++i) {
cin >> ar[i];
}
int dp[n];
dp[0] = 0;
dp[1] = ar[1] - ar[0];
for (int i = 2; i < n; ++i) {
dp[i] = min((dp[i - 1] + abs(ar[i] - ar[i - 1])),
dp[i - 2] + abs(ar[i] - ar[i - 2]));
}
cout << dp[n - 1];
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ar[n];
for (int i = 0; i < n; ++i) {
cin >> ar[i];
}
int dp[n];
dp[0] = 0;
dp[1] = abs(ar[1] - ar[0]);
for (int i = 2; i < n; ++i) {
dp[i] = min((dp[i - 1] + abs(ar[i] - ar[i - 1])),
dp[i - 2] + abs(ar[i] - ar[i - 2]));
}
cout << dp[n - 1];
return 0;
} | [
"call.add",
"call.arguments.change"
] | 955,601 | 955,602 | u518232099 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e5 + 10;
ll h[N], dp[N];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++)
cin >> h[i];
for (int i = n - 2; i >= 0; i--) {
dp[i] = dp[i + 1] + abs(h[i] - h[i + 1]);
if (i < n - 1)
dp[i] = min(dp[i], dp[i + 2] + abs(h[i] - h[i + 2]));
}
cout << dp[0] << "\n";
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e5 + 10;
ll h[N], dp[N];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++)
cin >> h[i];
for (int i = n - 2; i >= 0; i--) {
dp[i] = dp[i + 1] + abs(h[i] - h[i + 1]);
if (i < n - 2)
dp[i] = min(dp[i], dp[i + 2] + abs(h[i] - h[i + 2]));
}
cout << dp[0] << "\n";
return 0;
} | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 955,611 | 955,612 | u168698471 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
typedef pair<ll, ll> P;
#define M 1000000007
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<int> dp(n);
dp[0] = 0, dp[1] = abs(a[1] - a[0]);
for (int i = 2; i < n; i++) {
dp[i] =
min(abs(a[i] - a[i - 1]) + dp[i - 1], abs(a[i] - a[i - 2]) - dp[i - 2]);
}
cout << dp[n - 1];
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
typedef pair<ll, ll> P;
#define M 1000000007
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<int> dp(n);
dp[0] = 0, dp[1] = abs(a[1] - a[0]);
for (int i = 2; i < n; i++) {
dp[i] =
min(abs(a[i] - a[i - 1]) + dp[i - 1], abs(a[i] - a[i - 2]) + dp[i - 2]);
}
cout << dp[n - 1];
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 955,613 | 955,614 | u987476436 | cpp |
p03160 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const long long INF = 1LL << 60;
int n;
long long h[100010];
long long dp[100010];
int main() {
cin >> n;
for (int i = 0; i < n; ++i)
cin >> h[i];
for (int i = 0; i < 100010; ++i)
dp[i] = INF;
dp[0] = 0;
for (int i = 1; i < n; ++i) {
chmin(dp[i], dp[i - 1] + abs(h[1] - h[i - 1]));
if (i > 1)
chmin(dp[i], dp[i - 2] + abs(h[1] - h[i - 2]));
}
cout << dp[n - 1] << endl;
return 0;
} | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const long long INF = 1LL << 60;
int n;
long long h[100010];
long long dp[100010];
int main() {
cin >> n;
for (int i = 0; i < n; ++i)
cin >> h[i];
for (int i = 0; i < 100010; ++i)
dp[i] = INF;
dp[0] = 0;
for (int i = 1; i < n; ++i) {
chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
if (i > 1)
chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
cout << dp[n - 1] << endl;
return 0;
} | [
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 955,682 | 955,684 | u855985627 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define forn(i, n) for (int i = 0; i < n; i++)
#define forn1(i, n) for (int i = 1; i <= n; i++)
#define loop(i, sta, end, inc) for (int i = sta; i <= end; i += inc)
#define itr(it, l) for (auto it = l.begin(); it != l.end(); it++)
#define in(a, b, c) assert(b <= a && a <= c)
#define pb push_back
#define ll long long int
#define fi first
#define se second
#define ii pair<long long int, long long int>
#define vi vector<long long int>
#define vii vector<pair<long long int, long long int>>
#define all(cont) cont.begin(), cont.end()
#define rall(cont) cont.end(), cont.begin()
#define what_is(x) cerr << #x << " =" << x << " ";
#define error(args...) \
{ \
string _s = #args; \
replace(_s.begin(), _s.end(), ',', ' '); \
stringstream _ss(_s); \
istream_iterator<string> _it(_ss); \
err(_it, args); \
}
#define LINT_MAX 9223372036854775807
#define LINT_MIN -9223372036854775808
#define EPS 1e-9
#define MOD 1000000007
#define DEBUG 0
template <typename T, typename U> inline void amin(T &x, U y) {
if (y < x)
x = y;
}
template <typename T, typename U> inline void amax(T &x, U y) {
if (x < y)
x = y;
}
void err(istream_iterator<string> it) { cerr << endl; }
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
if (DEBUG == 0)
return;
cerr << *it << " = " << a << " ";
err(++it, args...);
}
int A[100000];
int dp[100000];
int main() {
// freopen("test.txt", "r", stdin);
int n;
cin >> n;
forn(i, n) cin >> A[i];
dp[0] = 0;
dp[1] = dp[0] + 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 - 2] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define forn(i, n) for (int i = 0; i < n; i++)
#define forn1(i, n) for (int i = 1; i <= n; i++)
#define loop(i, sta, end, inc) for (int i = sta; i <= end; i += inc)
#define itr(it, l) for (auto it = l.begin(); it != l.end(); it++)
#define in(a, b, c) assert(b <= a && a <= c)
#define pb push_back
#define ll long long int
#define fi first
#define se second
#define ii pair<long long int, long long int>
#define vi vector<long long int>
#define vii vector<pair<long long int, long long int>>
#define all(cont) cont.begin(), cont.end()
#define rall(cont) cont.end(), cont.begin()
#define what_is(x) cerr << #x << " =" << x << " ";
#define error(args...) \
{ \
string _s = #args; \
replace(_s.begin(), _s.end(), ',', ' '); \
stringstream _ss(_s); \
istream_iterator<string> _it(_ss); \
err(_it, args); \
}
#define LINT_MAX 9223372036854775807
#define LINT_MIN -9223372036854775808
#define EPS 1e-9
#define MOD 1000000007
#define DEBUG 0
template <typename T, typename U> inline void amin(T &x, U y) {
if (y < x)
x = y;
}
template <typename T, typename U> inline void amax(T &x, U y) {
if (x < y)
x = y;
}
void err(istream_iterator<string> it) { cerr << endl; }
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
if (DEBUG == 0)
return;
cerr << *it << " = " << a << " ";
err(++it, args...);
}
int A[100000];
int dp[100000];
int main() {
// freopen("test.txt", "r", stdin);
int n;
cin >> n;
forn(i, n) cin >> A[i];
dp[0] = 0;
dp[1] = dp[0] + 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",
"variable_access.subscript.index.change",
"io.output.change"
] | 955,704 | 955,708 | u858856811 | cpp |
p03160 | #include <cmath>
#include <iostream>
#include <vector>
using namespace std;
#define INF int(1e9)
int dp[100000000];
int main() {
int N;
cin >> N;
vector<int> v(N + 1);
for (int i = 1; i <= N; i++)
cin >> v[i];
dp[0] = 0;
dp[1] = 0;
dp[2] = v[1] - v[0];
for (int i = 3; i <= N; i++) {
dp[i] =
min(dp[i - 2] + abs(v[i] - v[i - 2]), dp[i - 1] + abs(v[i] - v[i - 1]));
}
cout << dp[N] << endl;
return 0;
} | #include <cmath>
#include <iostream>
#include <vector>
using namespace std;
#define INF int(1e9)
int dp[100000000];
int main() {
int N;
cin >> N;
vector<int> v(N + 1);
for (int i = 1; i <= N; i++)
cin >> v[i];
dp[0] = 0;
dp[1] = 0;
dp[2] = abs(v[2] - v[1]);
for (int i = 3; i <= N; i++) {
dp[i] =
min(dp[i - 2] + abs(v[i] - v[i - 2]), dp[i - 1] + abs(v[i] - v[i - 1]));
}
cout << dp[N] << endl;
return 0;
} | [
"call.add",
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 955,721 | 955,723 | u492352831 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.