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 | //雋ｰ縺・DP繝ｫ繝ｼ繝・
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep2(i, a, n) for (int i = (a); i < (n); i++)
#define repr(i, n) for (int i = (n); i >= 0; i--)
#define repr2(i, a, n) for (int i = (n); i >= (a); i--)
template <typename T, typename U> void Printarray(T f, U n) {
for (U i = 0; i < n; i++)
i != n ? cout << f[i] << " " : cout << f[i] << endl;
}
int main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
int n;
cin >> n;
int h[n];
rep(i, n) cin >> h[i];
int dp[n];
dp[0] = 0;
dp[1] = dp[0] + abs(h[1] - h[0]);
rep2(i, 2, n) {
dp[i] =
min(dp[i - 1] + abs(h[i] - h[i - 2]), dp[i - 2] + abs(h[i] - h[i - 2]));
}
// Printarray(dp,n);
cout << dp[n - 1] << endl;
}
| //雋ｰ縺・DP繝ｫ繝ｼ繝・
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep2(i, a, n) for (int i = (a); i < (n); i++)
#define repr(i, n) for (int i = (n); i >= 0; i--)
#define repr2(i, a, n) for (int i = (n); i >= (a); i--)
template <typename T, typename U> void Printarray(T f, U n) {
for (U i = 0; i < n; i++)
i != n ? cout << f[i] << " " : cout << f[i] << endl;
}
int main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
int n;
cin >> n;
int h[n];
rep(i, n) cin >> h[i];
int dp[n];
dp[0] = 0;
dp[1] = dp[0] + abs(h[1] - h[0]);
rep2(i, 2, n) {
dp[i] =
min(dp[i - 1] + abs(h[i] - h[i - 1]), dp[i - 2] + abs(h[i] - h[i - 2]));
}
// Printarray(dp,n);
cout << dp[n - 1] << endl;
}
| [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 954,144 | 954,145 | u277956366 | cpp |
p03160 | #include <algorithm>
#include <bits/stdc++.h>
#define pb push_back
#define mp make_pair
#define ll long long
#define vi vector<ll>
#define ff first
#define ss second
#define FOR(i, a, b) for (ll i = a; i < b; i++)
#define FORR(i, a, b) for (ll i = a - 1; i > b; i--)
#define MOD 10e9 + 7
#define fastScan \
ios_base::sync_with_stdio(0); \
cin.tie(NULL)
#define s(v) sort(v.begin(), v.end())
using namespace std;
// vector<bool> s(1000000,true);
// vector<ll> a;
/*void prime(){
FORor(ll i=2;i<1000000;i++){
if(s[i] == true) a.pb((ll)i);
ll j=2*i;
while(j<1000000){
if(s[j]!=FORalse) s[j]=FORalse;
j+=i;
}
}
}
ll bs(ll s, ll l,ll h){
ll m;
while(l<=h){
m = (l+h)>>1;
if(a[m] < s) l= m+1;
else h = m-1;
}
return l;
}
bool isprime(ll s, ll l,ll h){
ll m;
while(l<=h){
m = (l+h)>>1;
if(a[m]==s)return true;
if(a[m] < s) l= m+1;
else h = m-1;
}
return FORalse;
}
bool comp(pair<ll,ll> a, pair<ll,ll> b) {
if(a.FORirst == b.FORirst) return a.second<b.second;
else return a.FORirst < b.FORirst;
}
ll FORact(ll n){
if(n==1) return 1;
else return n*FORact(n-1);
}
ll gcd(ll a,ll b){
if(a==0)return b;
return (b%a,a);
}*/
void solve() {
ll n;
cin >> n;
vector<ll> a(n), dp(n);
for (ll i = 0; i < n; i++)
cin >> a[i];
dp[0] = 0;
dp[1] = dp[0] + (abs(a[1] - a[0]));
for (ll i = 2; i < n; i++) {
dp[i] = min((dp[i - 1] + abs(a[i] - a[i - 1])),
(dp[i - 2] + abs(a[i] - a[i - 1])));
}
cout << dp[n - 1] << endl;
return;
}
int main() {
fastScan;
ll T = 1;
// cin >> T;
while (T--) {
solve();
}
return 0;
} | #include <algorithm>
#include <bits/stdc++.h>
#define pb push_back
#define mp make_pair
#define ll long long
#define vi vector<ll>
#define ff first
#define ss second
#define FOR(i, a, b) for (ll i = a; i < b; i++)
#define FORR(i, a, b) for (ll i = a - 1; i > b; i--)
#define MOD 10e9 + 7
#define fastScan \
ios_base::sync_with_stdio(0); \
cin.tie(NULL)
#define s(v) sort(v.begin(), v.end())
using namespace std;
// vector<bool> s(1000000,true);
// vector<ll> a;
/*void prime(){
FORor(ll i=2;i<1000000;i++){
if(s[i] == true) a.pb((ll)i);
ll j=2*i;
while(j<1000000){
if(s[j]!=FORalse) s[j]=FORalse;
j+=i;
}
}
}
ll bs(ll s, ll l,ll h){
ll m;
while(l<=h){
m = (l+h)>>1;
if(a[m] < s) l= m+1;
else h = m-1;
}
return l;
}
bool isprime(ll s, ll l,ll h){
ll m;
while(l<=h){
m = (l+h)>>1;
if(a[m]==s)return true;
if(a[m] < s) l= m+1;
else h = m-1;
}
return FORalse;
}
bool comp(pair<ll,ll> a, pair<ll,ll> b) {
if(a.FORirst == b.FORirst) return a.second<b.second;
else return a.FORirst < b.FORirst;
}
ll FORact(ll n){
if(n==1) return 1;
else return n*FORact(n-1);
}
ll gcd(ll a,ll b){
if(a==0)return b;
return (b%a,a);
}*/
void solve() {
ll n;
cin >> n;
vector<ll> a(n), dp(n);
for (ll i = 0; i < n; i++)
cin >> a[i];
dp[0] = 0;
dp[1] = dp[0] + (abs(a[1] - a[0]));
for (ll 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;
}
int main() {
fastScan;
ll T = 1;
// cin >> T;
while (T--) {
solve();
}
return 0;
} | [
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 954,148 | 954,149 | u272056775 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> h(n, 0);
for (int i = 0; i < n; i++) {
cin >> h[i];
}
vector<int> dp(n + 1, 1e6);
dp[1] = 0;
for (int i = 1; i < n + 1; i++) {
for (auto j : {i + 1, i + 2}) {
if (j <= n) {
dp[j] = min(dp[j], dp[i] + abs(h[j - 1] - h[i - 1]));
}
}
}
cout << dp[n];
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> h(n, 0);
for (int i = 0; i < n; i++) {
cin >> h[i];
}
vector<int> dp(n + 1, 1e9 + 5);
dp[1] = 0;
for (int i = 1; i < n + 1; i++) {
for (auto j : {i + 1, i + 2}) {
if (j <= n) {
dp[j] = min(dp[j], dp[i] + abs(h[j - 1] - h[i - 1]));
}
}
}
cout << dp[n];
return 0;
}
| [
"literal.number.change",
"call.arguments.change"
] | 954,150 | 954,151 | u922651947 | cpp |
p03160 | #include <stdio.h>
#include <stdlib.h>
void chmin(int *a, int b) {
if (*a > b) {
*a = b;
}
}
int main(void) {
// Your code here!
int N;
int h[100000];
int N_[100000];
int i;
scanf("%d", &N);
for (i = 0; i < N; i++) {
scanf("%d", &h[i]);
}
N_[0] = 0;
for (i = 1; i < N; i++) {
N_[i] = 1000000;
}
chmin(&N_[1], abs(h[0] - h[1]));
for (i = 2; i < N; i++) {
chmin(&N_[i], N_[i - 1] + abs(h[i - 1] - h[i]));
chmin(&N_[i], N_[i - 2] + abs(h[i - 2] - h[i]));
}
printf("%d\n", N_[N - 1]);
}
| #include <stdio.h>
#include <stdlib.h>
#define MAX 2147483647
void chmin(int *a, int b) {
if (*a > b) {
*a = b;
}
}
int main(void) {
// Your code here!
int N;
int h[100000];
int N_[100000];
int i;
scanf("%d", &N);
for (i = 0; i < N; i++) {
scanf("%d", &h[i]);
}
N_[0] = 0;
for (i = 1; i < N; i++) {
N_[i] = MAX;
}
chmin(&N_[1], abs(h[0] - h[1]));
for (i = 2; i < N; i++) {
chmin(&N_[i], N_[i - 1] + abs(h[i - 1] - h[i]));
chmin(&N_[i], N_[i - 2] + abs(h[i - 2] - h[i]));
}
printf("%d\n", N_[N - 1]);
}
| [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 954,154 | 954,155 | u154818015 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
typedef long long int li;
typedef long double ld;
typedef vector<li> vi;
typedef pair<li, li> pi;
#define PB push_back
#define MP make_pair
#define F first
#define S second
#define B begin()
#define E end()
#define f(i, l, r) for (li i = l; i <= r; ++i)
#define fr(i, l, r) for (li i = l; i >= r; --i)
#define u_map unordered_map
#define endl "\n"
li fastpow(li base, li exp, li M) {
li res = 1;
while (exp > 0) {
if (exp & 1)
res = (res * base) % M;
base = (base * base) % M;
exp >>= 1;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
li n;
cin >> n;
li a[n + 1];
a[0] = 0;
for (li i = 1; i <= n; i++)
cin >> a[i];
li dp[n + 1];
dp[0] = 0;
dp[1] = 0;
f(i, 2, n) {
dp[i] =
min(dp[i - 1] + abs(a[i] - a[i - 1]), dp[i - 2] + abs(a[i] - a[i - 2]));
}
cout << dp[n];
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long int li;
typedef long double ld;
typedef vector<li> vi;
typedef pair<li, li> pi;
#define PB push_back
#define MP make_pair
#define F first
#define S second
#define B begin()
#define E end()
#define f(i, l, r) for (li i = l; i <= r; ++i)
#define fr(i, l, r) for (li i = l; i >= r; --i)
#define u_map unordered_map
#define endl "\n"
li fastpow(li base, li exp, li M) {
li res = 1;
while (exp > 0) {
if (exp & 1)
res = (res * base) % M;
base = (base * base) % M;
exp >>= 1;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
li n;
cin >> n;
li a[n + 1];
a[0] = 1e18;
for (li i = 1; i <= n; i++)
cin >> a[i];
li dp[n + 1];
dp[0] = 0;
dp[1] = 0;
f(i, 2, n) {
// if(i>)
dp[i] =
min(dp[i - 1] + abs(a[i] - a[i - 1]), dp[i - 2] + abs(a[i] - a[i - 2]));
}
cout << dp[n];
return 0;
} | [
"literal.number.change",
"assignment.value.change"
] | 954,156 | 954,157 | u292043617 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++)
cin >> arr[i];
int dp[n];
dp[0] = 0;
dp[1] = abs(arr[1] - arr[0]);
for (int i = 2; i < n; i++)
dp[i] = max(dp[i - 1] + abs(arr[i] - arr[i - 1]),
dp[i - 2] + abs(arr[i] - arr[i - 2]));
cout << dp[n - 1] << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++)
cin >> arr[i];
int dp[n];
dp[0] = 0;
dp[1] = abs(arr[1] - arr[0]);
for (int i = 2; i < n; i++)
dp[i] = min(dp[i - 1] + abs(arr[i] - arr[i - 1]),
dp[i - 2] + abs(arr[i] - arr[i - 2]));
cout << dp[n - 1] << endl;
} | [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 954,158 | 954,159 | u227478170 | cpp |
p03160 | #include "bits/stdc++.h"
int main() {
int N;
std::cin >> N;
std::vector<int> heights(N);
for (int i = 0; i < N; i++) {
std::cin >> heights[i];
// std::cout << heights[i] << std::endl;
}
// std::cout << heights[0] << "\n";
// std::cout << heights[1] << "\n";
// Writing the dp funcction
const int INF = 10e5 + 5;
std::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] = std::min(dp[j], dp[i] + abs(heights[j] - heights[i]));
}
}
}
// std::vector<int> dp(n, INF);
std::cout << dp[N - 1] << std::endl;
return 0;
} | #include "bits/stdc++.h"
int main() {
int N;
std::cin >> N;
std::vector<int> heights(N);
for (int i = 0; i < N; i++) {
std::cin >> heights[i];
// std::cout << heights[i] << std::endl;
}
// std::cout << heights[0] << "\n";
// std::cout << heights[1] << "\n";
// Writing the dp funcction
const int INF = 10e9 + 5;
std::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] = std::min(dp[j], dp[i] + abs(heights[j] - heights[i]));
}
}
}
// std::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(h[i] - h[j]));
// }
// }
// }
std::cout << dp[N - 1] << std::endl;
return 0;
} | [
"literal.number.change",
"expression.operation.binary.change"
] | 954,164 | 954,165 | u090445726 | cpp |
p03160 | #include "bits/stdc++.h"
int main() {
int N;
std::cin >> N;
std::vector<int> heights(N, 0);
for (int i = 0; i < N; i++) {
std::cin >> heights[i];
// std::cout << heights[i] << std::endl;
}
// std::cout << heights[0] << "\n";
// std::cout << heights[1] << "\n";
// Writing the dp funcction
const int INF = 10e5 + 5;
std::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] = std::min(dp[j], dp[i] + abs(heights[j] - heights[i]));
}
}
}
// std::vector<int> dp(n, INF);
std::cout << dp[N - 1] << std::endl;
return 0;
} | #include "bits/stdc++.h"
int main() {
int N;
std::cin >> N;
std::vector<int> heights(N);
for (int i = 0; i < N; i++) {
std::cin >> heights[i];
// std::cout << heights[i] << std::endl;
}
// std::cout << heights[0] << "\n";
// std::cout << heights[1] << "\n";
// Writing the dp funcction
const int INF = 10e9 + 5;
std::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] = std::min(dp[j], dp[i] + abs(heights[j] - heights[i]));
}
}
}
// std::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(h[i] - h[j]));
// }
// }
// }
std::cout << dp[N - 1] << std::endl;
return 0;
} | [
"call.arguments.change",
"literal.number.change",
"expression.operation.binary.change"
] | 954,166 | 954,165 | u090445726 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
int main() {
ll n, k;
cin >> n;
ll a[n];
for (ll i = 0; i < n; i++)
cin >> a[i];
ll dp[n];
for (ll i = 0; i < n; i++) {
dp[i] = 1000000;
}
dp[0] = 0;
dp[1] = abs(a[1] - a[0]);
for (ll i = 2; i < n; i++) {
for (ll j = i - 1; j >= i - 2; j--) {
dp[i] = min(dp[i], dp[j] + abs(a[i] - a[j]));
}
}
cout << dp[n - 1] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
int main() {
ll n, k;
cin >> n;
ll a[n];
for (ll i = 0; i < n; i++)
cin >> a[i];
ll dp[n];
for (ll i = 0; i < n; i++) {
dp[i] = 100000000000000;
}
dp[0] = 0;
dp[1] = abs(a[1] - a[0]);
for (ll i = 2; i < n; i++) {
for (ll j = i - 1; j >= i - 2; j--) {
dp[i] = min(dp[i], dp[j] + abs(a[j] - a[i]));
}
}
cout << dp[n - 1] << endl;
return 0;
} | [
"literal.number.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 954,167 | 954,168 | u028307850 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int h[n];
int d[n - 1];
for (int i = 1; i <= n; i++)
cin >> h[i];
d[0] = 0;
d[1] = abs(h[1] - h[0]);
for (int 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 - 1];
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int h[n];
int d[n];
for (int i = 0; i < n; i++)
cin >> h[i];
d[0] = 0;
d[1] = abs(h[1] - h[0]);
for (int 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 - 1];
}
| [
"expression.operation.binary.remove",
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 954,173 | 954,174 | u719855312 | cpp |
p03160 | // ysh_gpta
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set \
tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
using namespace std;
typedef long long ll;
#define vb vector<bool>
#define vi vector<ll>
#define vvi vector<vi>
#define pii pair<ll, ll>
#define vpii vector<pair<ll, ll>>
#define mkp make_pair
#define pb push_back
#define INF 1000000000000000
#define MOD 1000000007
#define ff first
#define ss second
#define FastIO \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
// ll gcd( ll a, ll b ){if(b==0) return a; else return gcd( b, a%b );}
// ll ncr(ll n,ll r){ll ans=1;r=min(r,n-r);for (int
// i=1;i<=r;i++){ans*=(n-r+i);ans/=i;}return ans;}
void printArray(vi &v) {
for (int i = 0; i < v.size(); i++)
cout << v[i] << " ";
cout << endl;
}
int main() {
FastIO ll n;
cin >> n;
vi v(n);
for (int i = 0; i < n; i++)
cin >> v[i];
vi dp(n);
dp[0] = 0;
dp[1] = abs(v[1] - v[0]);
for (int i = 2; i < n; i++) {
dp[i] =
min(abs(v[i] - v[i - 1]) + dp[i - 1], abs(v[i] - v[i - 2]) + dp[i - 2]);
}
printArray(dp);
cout << dp[n - 1];
return 0;
} | // ysh_gpta
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set \
tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
using namespace std;
typedef long long ll;
#define vb vector<bool>
#define vi vector<ll>
#define vvi vector<vi>
#define pii pair<ll, ll>
#define vpii vector<pair<ll, ll>>
#define mkp make_pair
#define pb push_back
#define INF 1000000000000000
#define MOD 1000000007
#define ff first
#define ss second
#define FastIO \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
// ll gcd( ll a, ll b ){if(b==0) return a; else return gcd( b, a%b );}
// ll ncr(ll n,ll r){ll ans=1;r=min(r,n-r);for (int
// i=1;i<=r;i++){ans*=(n-r+i);ans/=i;}return ans;}
void printArray(vi &v) {
for (int i = 0; i < v.size(); i++)
cout << v[i] << " ";
cout << endl;
}
int main() {
FastIO ll n;
cin >> n;
vi v(n);
for (int i = 0; i < n; i++)
cin >> v[i];
vi dp(n);
dp[0] = 0;
dp[1] = abs(v[1] - v[0]);
for (int i = 2; i < n; i++) {
dp[i] =
min(abs(v[i] - v[i - 1]) + dp[i - 1], abs(v[i] - v[i - 2]) + dp[i - 2]);
}
// printArray(dp);
cout << dp[n - 1];
return 0;
} | [
"call.remove"
] | 954,179 | 954,180 | u898771121 | cpp |
p03160 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define adrep(i, s, n) for (int i = (s); i < (n); i++)
using namespace std;
typedef long long ll;
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 ll INF = 1LL << 60;
int main() {
int N = 0;
cin >> N;
int h[N];
ll dp[N];
rep(i, N) {
dp[i] = INF;
cin >> h[i];
}
dp[0] = 0;
dp[1] = abs(h[0] - h[1]);
for (int i = 2; i < N - 1; i++) {
chmin(dp[i], dp[i - 1] + abs(h[i - 1] - h[i]));
chmin(dp[i], dp[i - 2] + abs(h[i - 2] - h[i]));
}
cout << dp[N - 1] << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define adrep(i, s, n) for (int i = (s); i < (n); i++)
using namespace std;
typedef long long ll;
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 ll INF = 1LL << 60;
int main() {
int N = 0;
cin >> N;
int h[N];
ll dp[N];
rep(i, N) {
dp[i] = INF;
cin >> h[i];
}
dp[0] = 0;
dp[1] = abs(h[0] - h[1]);
for (int i = 2; i < N; i++) {
chmin(dp[i], dp[i - 1] + abs(h[i - 1] - h[i]));
chmin(dp[i], dp[i - 2] + abs(h[i - 2] - h[i]));
}
cout << dp[N - 1] << endl;
}
| [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 954,181 | 954,182 | u978535698 | cpp |
p03160 | #include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int n;
cin >> n;
vector<int> h(n);
vector<int> dp(1e9);
rep(i, n) { cin >> h.at(i); }
dp[0] = 0;
dp[1] = abs(h[1] - h[0]);
for (size_t i = 2; i < n; i++) {
int prev, prev2;
prev = abs(h[i] - h[i - 1]) + dp[i - 1];
prev2 = abs(h[i] - h[i - 2]) + dp[i - 2];
dp[i] = min(prev, prev2);
}
cout << dp.at(n - 1) << endl;
}
| #include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int n;
cin >> n;
vector<int> h(n);
vector<int> dp(n, 1e9);
rep(i, n) { cin >> h.at(i); }
dp[0] = 0;
dp[1] = abs(h[1] - h[0]);
for (size_t i = 2; i < n; i++) {
int prev, prev2;
prev = abs(h[i] - h[i - 1]) + dp[i - 1];
prev2 = abs(h[i] - h[i - 2]) + dp[i - 2];
dp[i] = min(prev, prev2);
}
cout << dp.at(n - 1) << endl;
}
| [
"call.arguments.add"
] | 954,183 | 954,184 | u410305445 | cpp |
p03160 | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <cmath>
#include <functional>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, a, b) for (int i = a; i < b; i++)
int N;
int main() {
scanf("%d", &N);
vector<int> h(N);
vector<int> dp(N, 10001);
rep(i, 0, N) scanf("%d", &h[i]);
dp[0] = 0;
rep(i, 0, N - 1) {
dp[i + 1] = min(dp[i + 1], dp[i] + abs(h[i] - h[i + 1]));
if (i != N - 2)
dp[i + 2] = min(dp[i + 2], dp[i] + abs(h[i] - h[i + 2]));
}
printf("%d", dp[N - 1]);
return 0;
} | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <cmath>
#include <functional>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, a, b) for (int i = a; i < b; i++)
int N;
int main() {
scanf("%d", &N);
vector<int> h(N);
vector<int> dp(N, 2147483647);
rep(i, 0, N) scanf("%d", &h[i]);
dp[0] = 0;
rep(i, 0, N - 1) {
dp[i + 1] = min(dp[i + 1], dp[i] + abs(h[i] - h[i + 1]));
if (i != N - 2)
dp[i + 2] = min(dp[i + 2], dp[i] + abs(h[i] - h[i + 2]));
}
printf("%d", dp[N - 1]);
return 0;
} | [
"literal.number.change",
"call.arguments.change"
] | 954,196 | 954,197 | u128572736 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define INF 0x3f3f3f3f
#define MAXN 100010
#define endl "\n"
#define abs(a, b) ((a > b) ? a - b : b - a)
typedef long long int ll;
/* End */
int n;
ll a[MAXN];
ll pd[3];
int main() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i];
int m = 0;
pd[n - 1] = 0;
pd[n - 2] = abs(a[n - 2], a[n - 1]);
for (int i = n - 3; i >= 0; i--) {
pd[m] = min(pd[(m + 1) % 3] + abs(a[i], a[i + 1]),
pd[(m + 2) % 3] + abs(a[i], a[i + 2]));
m--;
if (m < 0)
m += 3;
}
cout << pd[(m + 1) % 3] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define INF 0x3f3f3f3f
#define MAXN 100010
#define endl "\n"
#define abs(a, b) ((a > b) ? a - b : b - a)
typedef long long int ll;
/* End */
int n;
ll a[MAXN];
ll pd[3];
int main() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i];
int m = 0;
pd[2] = 0;
pd[1] = abs(a[n - 2], a[n - 1]);
for (int i = n - 3; i >= 0; i--) {
pd[m] = min(pd[(m + 1) % 3] + abs(a[i], a[i + 1]),
pd[(m + 2) % 3] + abs(a[i], a[i + 2]));
m--;
if (m < 0)
m += 3;
}
cout << pd[(m + 1) % 3] << endl;
return 0;
}
| [
"assignment.variable.change",
"identifier.replace.remove",
"literal.replace.add",
"variable_access.subscript.index.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 954,198 | 954,199 | u885423967 | cpp |
p03160 | #include <bits/stdc++.h>
#define db1(x) cout << #x << "=" << x << '\n'
#define db2(x, y) cout << #x << "=" << x << "," << #y << "=" << y << '\n'
#define db3(x, y, z) \
cout << #x << "=" << x << "," << #y << "=" << y << "," << #z << "=" << z \
<< '\n'
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define repA(i, a, n) for (int i = a; i <= (n); ++i)
#define repD(i, a, n) for (int i = a; i >= (n); --i)
#define rep2(j, n) for (int j = 0; j < (n); ++j)
#define F first
#define S second
#define MP make_pair
#define PB push_back
#define maximum INT_MAX
using namespace std;
using ll = long long;
using ld = long double;
const int mod = 1e9 + 7;
const int inf = 1e5;
bool isPrime(ll n) {
for (ll i = 2; i * i <= n; ++i) {
if (n % i == 0) {
return false;
}
}
return true;
}
ll factorial(ll n) { return (n == 1 || n == 0) ? 1 : n * factorial(n - 1); }
ll power(ll x, ll y) {
ll res = 1;
x = x;
while (y > 0) {
if (y & 1)
res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
ll ncr(ll n, ll r) {
ll res = 1;
if (r > n)
return 0;
if (r > n - r)
r = n - r;
for (ll i = 0; i < r; i++) {
res *= (n - i);
res /= (i + 1);
}
return res;
}
ll gcd(ll a, ll b) {
if (a == 0)
return b;
return gcd(b % a, a);
}
ll lcm(ll a, ll b) { return (a / gcd(a, b) * b); }
ll max(ll a, ll b) {
ll ans = a > b ? a : b;
return ans;
}
ll min(ll a, ll b) {
ll ans = a < b ? a : b;
return ans;
}
// void print_set(vector<int> a)
// {
// cout<<a.size()<<"\n";
// for(auto x: a)
// {
// cout<<x<<' ';
// }
// cout<<"\n";
// }
void solve() {
ll n;
cin >> n;
vector<int> h(n);
rep(i, n) { cin >> h[i]; }
vector<int> dp(n, inf);
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j : {i + 1, i + 2}) {
if (j < n) {
dp[j] = min(dp[j], dp[i] + abs(h[j] - h[i]));
}
}
}
cout << dp[n - 1];
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
/*
void extendEuclid(int A, int B)
{
if(B==0)
{
x=1;
y=0;
}
else
{
extendEuclid(B, A%B);
int temp=x;
x=y;
y=temp-(A/B)*y;
}
}
int modularExponentiation(int X, int n, int M)
{
int result=1;
while(n>0)
{
if(n%2==1)
{
result=(x*result)%M;
}
else
{
x=x*x%M;
}
n=n/2;
return result;
}
}
int modInv(int A, int M)
{
extendEuclid(A, M)
return (x%M+M)%M;
}
int main()
{
int arr[4];
std::cin>>arr;
int A=arr[0], B=arr[1], C=arr[2], M=arr[3];
int D=modInv(C, M);
int E=modularExponentiation(A, B, M);
int ans=(D*E)%M;
std::cout<<ans;
}*/
/*int totalMultiples(int x, int a, int b, int c)
{
int un=x/a + x/b + x/c;
int in=x/lcm(a, b) + x/lcm(b, c) + x/lcm(a, c)
int fin=x/lcm(lcm(a, b), c)
int result=un-in+fin;
return result;
}
int binarySearch(vector<int> arr, int n)
{
int low=0;
int high=arr.size()-1;
while(low<high)
{
int mid=(high+low)/2;
if(arr[mid]<=n)
{
high=mid;
}
else
{
low=mid+1;
}
}
return low;
}
*/
/* Fast Factorization using Seive */
/*
int minPrime[n + 1];
for (int i = 2; i * i <= n; ++i) {
if (minPrime[i] == 0) { //If i is prime
for (int j = i * i; j <= n; j += i) {
if (minPrime[j] == 0) {
minPrime[j] = i;
}
}
}
}
for (int i = 2; i <= n; ++i) {
if (minPrime[i] == 0) {
minPrime[i] = i;
}
}
vector<int> factorize(int n) {
vector<int> res;
while (n != 1) {
res.push_back(minPrime[n]);
n /= minPrime[n];
}
return res;
}
*/ | #include <bits/stdc++.h>
#define db1(x) cout << #x << "=" << x << '\n'
#define db2(x, y) cout << #x << "=" << x << "," << #y << "=" << y << '\n'
#define db3(x, y, z) \
cout << #x << "=" << x << "," << #y << "=" << y << "," << #z << "=" << z \
<< '\n'
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define repA(i, a, n) for (int i = a; i <= (n); ++i)
#define repD(i, a, n) for (int i = a; i >= (n); --i)
#define rep2(j, n) for (int j = 0; j < (n); ++j)
#define F first
#define S second
#define MP make_pair
#define PB push_back
#define maximum INT_MAX
using namespace std;
using ll = long long;
using ld = long double;
const int mod = 1e9 + 7;
const int inf = 1e9 + 5;
bool isPrime(ll n) {
for (ll i = 2; i * i <= n; ++i) {
if (n % i == 0) {
return false;
}
}
return true;
}
ll factorial(ll n) { return (n == 1 || n == 0) ? 1 : n * factorial(n - 1); }
ll power(ll x, ll y) {
ll res = 1;
x = x;
while (y > 0) {
if (y & 1)
res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
ll ncr(ll n, ll r) {
ll res = 1;
if (r > n)
return 0;
if (r > n - r)
r = n - r;
for (ll i = 0; i < r; i++) {
res *= (n - i);
res /= (i + 1);
}
return res;
}
ll gcd(ll a, ll b) {
if (a == 0)
return b;
return gcd(b % a, a);
}
ll lcm(ll a, ll b) { return (a / gcd(a, b) * b); }
ll max(ll a, ll b) {
ll ans = a > b ? a : b;
return ans;
}
ll min(ll a, ll b) {
ll ans = a < b ? a : b;
return ans;
}
// void print_set(vector<int> a)
// {
// cout<<a.size()<<"\n";
// for(auto x: a)
// {
// cout<<x<<' ';
// }
// cout<<"\n";
// }
void solve() {
ll n;
cin >> n;
vector<int> h(n);
rep(i, n) { cin >> h[i]; }
vector<int> dp(n, inf);
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j : {i + 1, i + 2}) {
if (j < n) {
dp[j] = min(dp[j], dp[i] + abs(h[j] - h[i]));
}
}
}
cout << dp[n - 1];
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
/*
void extendEuclid(int A, int B)
{
if(B==0)
{
x=1;
y=0;
}
else
{
extendEuclid(B, A%B);
int temp=x;
x=y;
y=temp-(A/B)*y;
}
}
int modularExponentiation(int X, int n, int M)
{
int result=1;
while(n>0)
{
if(n%2==1)
{
result=(x*result)%M;
}
else
{
x=x*x%M;
}
n=n/2;
return result;
}
}
int modInv(int A, int M)
{
extendEuclid(A, M)
return (x%M+M)%M;
}
int main()
{
int arr[4];
std::cin>>arr;
int A=arr[0], B=arr[1], C=arr[2], M=arr[3];
int D=modInv(C, M);
int E=modularExponentiation(A, B, M);
int ans=(D*E)%M;
std::cout<<ans;
}*/
/*int totalMultiples(int x, int a, int b, int c)
{
int un=x/a + x/b + x/c;
int in=x/lcm(a, b) + x/lcm(b, c) + x/lcm(a, c)
int fin=x/lcm(lcm(a, b), c)
int result=un-in+fin;
return result;
}
int binarySearch(vector<int> arr, int n)
{
int low=0;
int high=arr.size()-1;
while(low<high)
{
int mid=(high+low)/2;
if(arr[mid]<=n)
{
high=mid;
}
else
{
low=mid+1;
}
}
return low;
}
*/
/* Fast Factorization using Seive */
/*
int minPrime[n + 1];
for (int i = 2; i * i <= n; ++i) {
if (minPrime[i] == 0) { //If i is prime
for (int j = i * i; j <= n; j += i) {
if (minPrime[j] == 0) {
minPrime[j] = i;
}
}
}
}
for (int i = 2; i <= n; ++i) {
if (minPrime[i] == 0) {
minPrime[i] = i;
}
}
vector<int> factorize(int n) {
vector<int> res;
while (n != 1) {
res.push_back(minPrime[n]);
n /= minPrime[n];
}
return res;
}
*/ | [
"literal.number.change"
] | 954,200 | 954,201 | u128189308 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define INF INT_MAX
#define MOD 1000000007
typedef long long ll;
typedef vector<int> vi;
typedef vector<vector<int>> vii;
int main() {
int n;
cin >> n;
vi stones(n + 1, 0);
for (int i = 1; i <= n; i++) {
cin >> stones[i];
}
vi dp(n + 1);
dp[2] = abs(stones[1] - stones[0]);
for (int i = 3; i <= n; i++) {
dp[i] = min(abs(stones[i] - stones[i - 2]) + dp[i - 2],
abs(stones[i] - stones[i - 1]) + dp[i - 1]);
}
cout << dp[n] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define INF INT_MAX
#define MOD 1000000007
typedef long long ll;
typedef vector<int> vi;
typedef vector<vector<int>> vii;
int main() {
int n;
cin >> n;
vi stones(n + 1);
for (int i = 1; i <= n; i++) {
cin >> stones[i];
}
vi dp(n + 1);
dp[2] = abs(stones[2] - stones[1]);
for (int i = 3; i <= n; i++) {
dp[i] = min(abs(stones[i] - stones[i - 2]) + dp[i - 2],
abs(stones[i] - stones[i - 1]) + dp[i - 1]);
}
cout << dp[n] << endl;
return 0;
} | [
"call.arguments.change",
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 954,211 | 954,212 | u615813234 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define INF INT_MAX
#define MOD 1000000007
typedef long long ll;
typedef vector<int> vi;
typedef vector<vector<int>> vii;
int main() {
int n;
cin >> n;
vi stones(n + 1);
for (int i = 1; i <= n; i++) {
cin >> stones[i];
}
vi dp(n + 1, 0);
dp[2] = abs(stones[1] - stones[0]);
for (int i = 3; i <= n; i++) {
dp[i] = min(abs(stones[i] - stones[i - 2]) + dp[i - 2],
abs(stones[i] - stones[i - 1]) + dp[i - 1]);
}
cout << dp[n] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define INF INT_MAX
#define MOD 1000000007
typedef long long ll;
typedef vector<int> vi;
typedef vector<vector<int>> vii;
int main() {
int n;
cin >> n;
vi stones(n + 1);
for (int i = 1; i <= n; i++) {
cin >> stones[i];
}
vi dp(n + 1);
dp[2] = abs(stones[2] - stones[1]);
for (int i = 3; i <= n; i++) {
dp[i] = min(abs(stones[i] - stones[i - 2]) + dp[i - 2],
abs(stones[i] - stones[i - 1]) + dp[i - 1]);
}
cout << dp[n] << endl;
return 0;
} | [
"call.arguments.change",
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 954,213 | 954,212 | u615813234 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define INF INT_MAX
#define MOD 1000000007
typedef long long ll;
typedef vector<int> vi;
typedef vector<vector<int>> vii;
int main() {
int n;
cin >> n;
vi stones(n + 1);
for (int i = 1; i <= n; i++) {
cin >> stones[i];
}
vi dp(n + 1);
dp[2] = abs(stones[1] - stones[0]);
for (int i = 3; i <= n; i++) {
dp[i] = min(abs(stones[i] - stones[i - 2]) + dp[i - 2],
abs(stones[i] - stones[i - 1]) + dp[i - 1]);
}
cout << dp[n] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define INF INT_MAX
#define MOD 1000000007
typedef long long ll;
typedef vector<int> vi;
typedef vector<vector<int>> vii;
int main() {
int n;
cin >> n;
vi stones(n + 1);
for (int i = 1; i <= n; i++) {
cin >> stones[i];
}
vi dp(n + 1);
dp[2] = abs(stones[2] - stones[1]);
for (int i = 3; i <= n; i++) {
dp[i] = min(abs(stones[i] - stones[i - 2]) + dp[i - 2],
abs(stones[i] - stones[i - 1]) + dp[i - 1]);
}
cout << dp[n] << endl;
return 0;
} | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 954,214 | 954,212 | u615813234 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define sp ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL)
int main() {
sp;
////////////////To Remove//////////////
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
///////////////////////////////////////
int n;
cin >> n;
int A[n], dp[n] = {0};
for (int i = 0; i < n; ++i)
cin >> A[i];
dp[1] = 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];
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define sp ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL)
int main() {
sp;
////////////////To Remove//////////////
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
///////////////////////////////////////
int n;
cin >> n;
int A[n], dp[n] = {0};
for (int i = 0; i < n; ++i)
cin >> A[i];
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];
return 0;
} | [
"call.add",
"call.arguments.change"
] | 954,217 | 954,218 | u248276426 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define N 100000
int a[N + 1], dp[N + 1];
int main() {
int n, i;
scanf("%d", &n);
for (i = 1; i <= n; i++)
scanf("%d", a + i);
dp[1] = 0;
dp[2] = abs(a[2] - a[1]);
for (i = 3; i <= n; i++)
dp[i] =
max(dp[i - 1] + abs(a[i] - a[i - 1]), dp[i - 2] + abs(a[i] - a[i - 2]));
printf("%d\n", dp[n]);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define N 100000
int a[N + 1], dp[N + 1];
int main() {
int n, i;
scanf("%d", &n);
for (i = 1; i <= n; i++)
scanf("%d", a + i);
dp[1] = 0;
dp[2] = abs(a[2] - a[1]);
for (i = 3; i <= n; i++)
dp[i] =
min(dp[i - 1] + abs(a[i] - a[i - 1]), dp[i - 2] + abs(a[i] - a[i - 2]));
printf("%d\n", dp[n]);
return 0;
} | [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 954,227 | 954,228 | u058625538 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n, 0);
vector<int> dp(n, 0);
for (int i = 0; i < n; i++)
cin >> a[i];
if (n == 2) {
cout << abs(a[1] - a[0]);
return 0;
}
dp[1] = 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;
int main() {
int n;
cin >> n;
vector<int> a(n, 0);
vector<int> dp(n, 0);
for (int i = 0; i < n; i++)
cin >> a[i];
if (n == 2) {
cout << abs(a[1] - a[0]);
return 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];
} | [
"call.add",
"call.arguments.change"
] | 954,231 | 954,232 | u180641794 | 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 v[N];
v[N - 1] = 0;
v[N - 2] = abs(h[N] - h[N - 1]);
for (int i = N - 3; i >= 0; i--) {
v[i] =
min(abs(h[i] - h[i + 1]) + v[i + 1], abs(h[i] - h[i + 2]) + v[i + 2]);
}
cout << v[0];
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 v[N];
v[N - 1] = 0;
v[N - 2] = abs(h[N - 1] - h[N - 2]);
for (int i = N - 3; i >= 0; i--) {
v[i] =
min(abs(h[i] - h[i + 1]) + v[i + 1], abs(h[i] - h[i + 2]) + v[i + 2]);
}
cout << v[0];
return 0;
}
| [
"assignment.change",
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 954,233 | 954,234 | u169936115 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAX = 1e5 + 10;
const ll INF = 1e4;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
int main() {
int N;
cin >> N;
int h[MAX];
for (int i = 0; i < N; ++i)
cin >> h[i];
ll dp[MAX];
for (int i = 0; i < MAX; ++i)
dp[i] = INF;
dp[0] = 0;
for (int i = 0; i < N; ++i) {
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;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAX = 1e5 + 10;
const ll INF = 1e9 + 1;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
int main() {
int N;
cin >> N;
int h[MAX];
for (int i = 0; i < N; ++i)
cin >> h[i];
ll dp[MAX];
for (int i = 0; i < MAX; ++i)
dp[i] = INF;
dp[0] = 0;
for (int i = 0; i < N; ++i) {
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;
} | [
"literal.number.change"
] | 954,237 | 954,236 | u378125390 | cpp |
p03160 | /******************************************************************************
Online C++ Compiler.
Code, Compile, Run and Debug C++ program online.
Write your code in this editor and press "Run" button to compile and execute it.
*******************************************************************************/
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, k;
cin >> n;
int a[n + 1];
for (i = 1; i <= n; i++)
cin >> a[i];
int dp[n + 1];
dp[0] = 0;
dp[1] = a[1];
dp[2] = abs(a[2] - a[1]);
for (i = 3; i <= n; i++) {
dp[i] = min((dp[i - 1] + abs(a[i] - a[i - 1])),
(dp[i - 2] + abs(a[i] - a[i - 2])));
}
cout << dp[n];
return 0;
}
| /******************************************************************************
Online C++ Compiler.
Code, Compile, Run and Debug C++ program online.
Write your code in this editor and press "Run" button to compile and execute it.
*******************************************************************************/
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, k;
cin >> n;
int a[n + 1];
for (i = 1; i <= n; i++)
cin >> a[i];
int dp[n + 1];
dp[0] = 0;
dp[1] = 0;
dp[2] = abs(a[2] - a[1]);
for (i = 3; i <= n; i++) {
dp[i] = min((dp[i - 1] + abs(a[i] - a[i - 1])),
(dp[i - 2] + abs(a[i] - a[i - 2])));
}
cout << dp[n];
return 0;
}
| [
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add"
] | 954,238 | 954,239 | u055115268 | cpp |
p03160 |
#include <bits/stdc++.h>
using namespace std;
// Let's just be lazy in typing "typedef"
#define td typedef
// Data types
td long long ll;
td unsigned long long int ull;
td long double ld;
// Containers
td vector<int> vi;
td vector<ll> vll;
td map<int, int> mii;
td map<ll, ll> mll;
td pair<int, int> pii;
td pair<ll, ll> pll;
// Container functions
#define pb push_back
#define mp make_pair
#define n1 first // for pairs
#define n2 second
#define fill(x, v) memset(x, v, sizeof(x))
// Important Constants
#define inf (int)1e9
#define eps (ld)1e-12
#define mod (ll)(1e9 + 7)
#define endl '\n'
// Traversing containers
#define tr(x, itr) \
for (typeof(x.begin()) itr = x.begin(); itr != x.end(); \
itr++) // Use iterator to iterate from beginning of a data structure to
// its end
#define all(x) x.begin(), x.end() // all the elements of a DS
#define rep(i, n) for (int i = 0; i < n; i++) // increasing for loop from 0 to n
#define inc(i, a, b) \
for (int i = a; i <= b; i++) // increasing for loop from a to b
#define dec(i, a, b) \
for (int i = b; i >= a; i--) // decreasing for loop from b to a
#define in(a, b) ((b).find(a) != (b).end()) // check if a is inside b
#define cases \
ll t; \
cin >> t; \
while (t--) // declare testcases, take input and start while loop
#define abs(x) (x < 0 ? -x : x)
#define sqr(x) (x * x)
// I/O declare n and take input
#define cint(n) \
int n; \
cin >> n
// I/O optimizations
#define io1 ios::sync_with_stdio(false)
#define io2 \
cin.tie(NULL); \
cout.tie(NULL)
// Important functions
ll gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
ll lcm(int a, int b) { return a * b / gcd(a, b); }
vll h, dp;
int main() {
io1;
io2;
int n, x;
cin >> n;
dp.assign(n, inf);
for (int i = 0; i < n; i++)
cin >> x, h.pb(x);
dp[0] = 0;
dp[1] = abs(h[0] - h[1]);
for (int i = 2; i < n; i++) {
int two = h[i - 2] - h[i];
int one = h[i - 1] - h[i];
dp[i] = min(dp[i - 1] + abs(one), dp[i - 2] + abs(two));
}
cout << dp[n - 1] << endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
// Let's just be lazy in typing "typedef"
#define td typedef
// Data types
td long long ll;
td unsigned long long int ull;
td long double ld;
// Containers
td vector<int> vi;
td vector<ll> vll;
td map<int, int> mii;
td map<ll, ll> mll;
td pair<int, int> pii;
td pair<ll, ll> pll;
// Container functions
#define pb push_back
#define mp make_pair
#define n1 first // for pairs
#define n2 second
#define fill(x, v) memset(x, v, sizeof(x))
// Important Constants
#define inf (int)1e9
#define eps (ld)1e-12
#define mod (ll)(1e9 + 7)
#define endl '\n'
// Traversing containers
#define tr(x, itr) \
for (typeof(x.begin()) itr = x.begin(); itr != x.end(); \
itr++) // Use iterator to iterate from beginning of a data structure to
// its end
#define all(x) x.begin(), x.end() // all the elements of a DS
#define rep(i, n) for (int i = 0; i < n; i++) // increasing for loop from 0 to n
#define inc(i, a, b) \
for (int i = a; i <= b; i++) // increasing for loop from a to b
#define dec(i, a, b) \
for (int i = b; i >= a; i--) // decreasing for loop from b to a
#define in(a, b) ((b).find(a) != (b).end()) // check if a is inside b
#define cases \
ll t; \
cin >> t; \
while (t--) // declare testcases, take input and start while loop
#define abs(x) (x < 0 ? -x : x)
#define sqr(x) (x * x)
// I/O declare n and take input
#define cint(n) \
int n; \
cin >> n
// I/O optimizations
#define io1 ios::sync_with_stdio(false)
#define io2 \
cin.tie(NULL); \
cout.tie(NULL)
// Important functions
ll gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
ll lcm(int a, int b) { return a * b / gcd(a, b); }
vll h, dp;
int main() {
io1;
io2;
int n, x;
cin >> n;
dp.assign(n, inf);
for (int i = 0; i < n; i++)
cin >> x, h.pb(x);
dp[0] = 0;
dp[1] = abs((h[0] - h[1]));
for (int i = 2; i < n; i++) {
int two = h[i - 2] - h[i];
int one = h[i - 1] - h[i];
dp[i] = min(dp[i - 1] + abs(one), dp[i - 2] + abs(two));
}
cout << dp[n - 1] << endl;
// for(int i=0;i<n;i++)cout << dp[i] << ' ';
return 0;
} | [
"call.arguments.change"
] | 954,242 | 954,243 | u169184726 | cpp |
p03160 | /* Life is all about calculated risks.
But man am I bad at math. */
#include <algorithm>
#include <iostream>
#include <vector>
#define ll long long int
#define INF 1000000000000
#define MOD 1000000007
#define DEBUG(x) cerr << "> " << #x << ':' << x << endl;
using namespace std;
ll f(ll stone);
ll n, k;
ll h[100100];
vector<ll> dp(100100, -1);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k;
for (ll i = 1; i <= n; i++) {
cin >> h[i];
}
cout << f(n) << endl;
return 0;
}
ll f(ll stone) {
if (dp[stone] != -1) {
return dp[stone];
}
if (stone == 1) {
return dp[stone] = 0;
}
ll min_sum = INF;
for (ll i = 1; (i <= k) && (stone - i > 0); i++) {
if (f(stone - i) + abs(h[stone] - h[stone - i]) < min_sum) {
min_sum = f(stone - i) + abs(h[stone] - h[stone - i]);
}
}
return dp[stone] = min_sum;
} | /* Life is all about calculated risks.
But man am I bad at math. */
#include <algorithm>
#include <iostream>
#include <vector>
#define ll long long int
#define INF 1000000000000
#define MOD 1000000007
#define DEBUG(x) cerr << "> " << #x << ':' << x << endl;
using namespace std;
ll f(ll stone);
ll n, k;
ll h[100100];
vector<ll> dp(100100, -1);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
k = 2;
for (ll i = 1; i <= n; i++) {
cin >> h[i];
}
cout << f(n) << endl;
return 0;
}
ll f(ll stone) {
if (dp[stone] != -1) {
return dp[stone];
}
if (stone == 1) {
return dp[stone] = 0;
}
ll min_sum = INF;
for (ll i = 1; (i <= k) && (stone - i > 0); i++) {
if (f(stone - i) + abs(h[stone] - h[stone - i]) < min_sum) {
min_sum = f(stone - i) + abs(h[stone] - h[stone - i]);
}
}
return dp[stone] = min_sum;
} | [
"expression.operation.binary.remove",
"assignment.add"
] | 954,244 | 954,245 | u371435984 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++)
cin >> v[i];
int dp[n + 1];
dp[0] = 0;
dp[1] = abs(v[1] - v[0]);
for (int i = 2; i < n; i++) {
dp[i] =
min(dp[i - 1] + abs(v[i] - v[i - 1]), dp[i - 2] + abs(v[i] - v[i - 2]));
}
int sum = 0;
for (int i = 1; i < n; i++) {
sum = max(dp[i - 1], dp[i]);
}
cout << sum;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++)
cin >> v[i];
int dp[n + 1];
dp[0] = 0;
dp[1] = abs(v[1] - v[0]);
for (int i = 2; i < n; i++) {
dp[i] =
min(dp[i - 1] + abs(v[i] - v[i - 1]), dp[i - 2] + abs(v[i] - v[i - 2]));
}
int sum = 0;
for (int i = 1; i < n; i++) {
sum = max(dp[i - 1], dp[i]);
}
cout << dp[n - 1];
} | [
"io.output.change"
] | 954,246 | 954,247 | u379187386 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define int long long int
signed main() {
int n;
cin >> n;
int ar[n + 1];
for (int i = 1; i <= n; ++i)
cin >> ar[i];
int dp[100010];
memset(dp, 0, sizeof dp);
dp[1] = 0;
dp[2] = abs(ar[1] - ar[2]);
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];
} | #include <bits/stdc++.h>
using namespace std;
#define int long long int
signed main() {
int n;
cin >> n;
int ar[n + 1];
for (int i = 1; i <= n; ++i)
cin >> ar[i];
int dp[100010];
memset(dp, 0, sizeof dp);
dp[1] = 0;
dp[2] = abs(ar[1] - ar[2]);
for (int i = 3; 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];
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 954,249 | 954,250 | u905126179 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define int long long int
signed main() {
int n;
cin >> n;
int ar[n + 1];
for (int i = 1; i <= n; ++i)
cin >> ar[i];
int dp[n + 1];
memset(dp, 0, sizeof dp);
dp[1] = 0;
dp[2] = abs(ar[1] - ar[2]);
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];
} | #include <bits/stdc++.h>
using namespace std;
#define int long long int
signed main() {
int n;
cin >> n;
int ar[n + 1];
for (int i = 1; i <= n; ++i)
cin >> ar[i];
int dp[100010];
memset(dp, 0, sizeof dp);
dp[1] = 0;
dp[2] = abs(ar[1] - ar[2]);
for (int i = 3; 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];
} | [
"identifier.replace.remove",
"literal.replace.add",
"expression.operation.binary.change",
"expression.operation.binary.remove",
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 954,251 | 954,250 | u905126179 | cpp |
p03160 | #include <bits/stdc++.h>
#define H 100010
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<int> h(n);
for (int i = 0; i < n; i++) {
scanf("%d", &h[i]);
}
vector<int> dp(n, H);
dp[0] = 0;
for (int i = 1; i < n; i++) {
for (int k = 1; k <= 2; k++) {
if (i >= k)
dp[i] = min(dp[i], dp[i - k] + abs(h[i] - h[i - k]));
}
}
printf("%d\n", dp[n - 1]);
return 0;
} | #include <bits/stdc++.h>
#define H 1000000000
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<int> h(n);
for (int i = 0; i < n; i++) {
scanf("%d", &h[i]);
}
vector<int> dp(n, H);
dp[0] = 0;
for (int i = 1; i < n; i++) {
for (int k = 1; k <= 2; k++) {
if (i >= k)
dp[i] = min(dp[i], dp[i - k] + abs(h[i] - h[i - k]));
}
}
printf("%d\n", dp[n - 1]);
return 0;
} | [
"preprocessor.define.value.change",
"literal.integer.change"
] | 954,254 | 954,255 | u431658223 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define deb(x) cout << '>' << #x << ':' << x << endl;
#define REP(i, n) for (ll i = 0; i < (n); i++)
#define FOR(i, a, b) for (ll i = (a); i <= (b); i++)
#define FORD(i, a, b) for (ll i = (a); i >= (b); i--)
typedef long long int ll;
ll go(ll *h, ll n, ll index, ll *dp) {
if (dp[index] != 0) {
return dp[index];
}
if (n < 0) {
return 0;
}
if (n == 0) {
return 0;
}
if (n == 1) {
return 0;
}
if (n == 2) {
return abs(h[1] - h[0]);
}
ll ans1 = go(h + 1, n - 1, index + 1, dp) + abs(h[1] - h[0]);
ll ans2 = go(h + 2, n - 2, index + 2, dp) + abs(h[2] - h[0]);
return dp[index] = min(ans1, ans2);
}
int main() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
ll n;
cin >> n;
ll *h = new ll[n];
ll *dp = new ll[n];
REP(i, n) {
cin >> h[i];
dp[i] = 0;
}
dp[0] = 0;
dp[1] = h[1] - h[0];
for (int i = 2; i < n; i++) {
dp[i] =
min(dp[i - 1] + abs(h[i - 1] - h[i]), dp[i - 2] + abs(h[i - 2] - h[i]));
}
cout << dp[n - 1] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define deb(x) cout << '>' << #x << ':' << x << endl;
#define REP(i, n) for (ll i = 0; i < (n); i++)
#define FOR(i, a, b) for (ll i = (a); i <= (b); i++)
#define FORD(i, a, b) for (ll i = (a); i >= (b); i--)
typedef long long int ll;
ll go(ll *h, ll n, ll index, ll *dp) {
if (dp[index] != 0) {
return dp[index];
}
if (n < 0) {
return 0;
}
if (n == 0) {
return 0;
}
if (n == 1) {
return 0;
}
if (n == 2) {
return abs(h[1] - h[0]);
}
ll ans1 = go(h + 1, n - 1, index + 1, dp) + abs(h[1] - h[0]);
ll ans2 = go(h + 2, n - 2, index + 2, dp) + abs(h[2] - h[0]);
return dp[index] = min(ans1, ans2);
}
int main() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
ll n;
cin >> n;
ll *h = new ll[n];
ll *dp = new ll[n];
REP(i, n) {
cin >> h[i];
dp[i] = 0;
}
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 - 1] - h[i]), dp[i - 2] + abs(h[i - 2] - h[i]));
}
cout << dp[n - 1] << endl;
return 0;
}
| [
"call.add",
"call.arguments.change"
] | 954,256 | 954,257 | u678293555 | 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;
vector<int> vec(100000);
vector<int> memo(100000);
int solve(int i) {
if (memo[i] < INF)
return memo[i];
if (i == 0)
return 0;
int res;
res = solve(i - 1) + abs(vec.at(i) - vec.at(i - 1));
if (i > 1)
chmin(res, solve(i - 2) + abs(vec.at(i) - vec.at(i - 2)));
return memo[i] = res;
}
int main() {
int N;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> vec.at(i);
}
for (int i = 0; i < N; i++) {
memo.at(i) = INF;
}
cout << solve(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;
vector<int> vec(100000);
vector<long long> memo(100000);
int solve(int i) {
if (memo[i] < INF)
return memo[i];
if (i == 0)
return 0;
int res;
res = solve(i - 1) + abs(vec.at(i) - vec.at(i - 1));
if (i > 1)
chmin(res, solve(i - 2) + abs(vec.at(i) - vec.at(i - 2)));
return memo[i] = res;
}
int main() {
int N;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> vec.at(i);
}
for (int i = 0; i < N; i++) {
memo.at(i) = INF;
}
cout << solve(N - 1) << endl;
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 954,262 | 954,263 | u128837995 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define pb push_back
#define MOD 1000000007
#define inf 3e18
#define ld long double
//#define mp make_pair
#define vpll vector<pair<ll, ll>>
#define sll set<ll>
#define vll vector<ll>
#define vld vector<ld>
#define vvll vector<vector<ll>>
#define vvld vector<vector<ld>>
#define pll pair<ll, ll>
#define vvpll vector<vector<pair<ll, ll>>>
#define pqll priority_queue<ll>
#define mll map<ll, ll>
#define mlc map<ll, char>
#define um unordered_map
#define umll um<ll, ll>
#define umlc um<ll, char>
#define umcl um<char, ll>
#define all(x) x.begin(), x.end()
#define fi first
#define se second
#define test \
ll Testcases; \
cin >> Testcases; \
while (Testcases--)
#define fastIO \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define db(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
cerr << " " << name << " : " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
void inp_out() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
freopen("debug.txt", "w", stderr);
#endif
}
int main() {
fastIO inp_out();
ll n;
cin >> n;
vll a(n);
for (ll i = 0; i < n; ++i) {
cin >> a[i];
}
ll dp[n];
dp[0] = 0;
for (ll i = 1; i < n; ++i) {
ll val = dp[i - 1] + abs(a[i] - a[i - 1]);
if (i > 1) {
val = min(val, dp[i - 2] + abs(a[i - 2] - a[i]));
}
dp[i] = val;
}
cout << dp[n - 1];
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define pb push_back
#define MOD 1000000007
#define inf 3e18
#define ld long double
//#define mp make_pair
#define vpll vector<pair<ll, ll>>
#define sll set<ll>
#define vll vector<ll>
#define vld vector<ld>
#define vvll vector<vector<ll>>
#define vvld vector<vector<ld>>
#define pll pair<ll, ll>
#define vvpll vector<vector<pair<ll, ll>>>
#define pqll priority_queue<ll>
#define mll map<ll, ll>
#define mlc map<ll, char>
#define um unordered_map
#define umll um<ll, ll>
#define umlc um<ll, char>
#define umcl um<char, ll>
#define all(x) x.begin(), x.end()
#define fi first
#define se second
#define test \
ll Testcases; \
cin >> Testcases; \
while (Testcases--)
#define fastIO \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define db(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
cerr << " " << name << " : " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
void inp_out() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
freopen("debug.txt", "w", stderr);
#endif
}
int main() {
fastIO
// inp_out();
ll n;
cin >> n;
vll a(n);
for (ll i = 0; i < n; ++i) {
cin >> a[i];
}
ll dp[n];
dp[0] = 0;
for (ll i = 1; i < n; ++i) {
ll val = dp[i - 1] + abs(a[i] - a[i - 1]);
if (i > 1) {
val = min(val, dp[i - 2] + abs(a[i - 2] - a[i]));
}
dp[i] = val;
}
cout << dp[n - 1];
return 0;
}
| [
"variable_declaration.remove"
] | 954,266 | 954,267 | u294050910 | cpp |
p03160 | #include "bits/stdc++.h"
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, a, b) for (int i = (b)-1; i >= (a); --i)
#define ALL(v) v.begin(), v.end()
#define FS first
#define SC second
#define SZ(a) int((a).size())
#define SORT(c) sort((c).begin(), (c).end())
#define MEMSET(v, h) memset((v), h, sizeof(v))
#define SQR(x) ((x) * (x))
#define BIT(n) (1LL << (n))
#define PCNT(x) __builtin_popcountll(x)
#define PB push_back
#define MP make_pair
#define endl "\n"
using namespace std;
typedef long long LL;
typedef long double LD;
typedef vector<int> VI;
typedef vector<LL> VLL;
typedef vector<bool> VB;
typedef vector<vector<int>> VVI;
typedef vector<vector<bool>> VVB;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef vector<PII> VPII;
const LL MOD = 1000000007ll;
const LL INF = 2000000000ll;
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 dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
long power(long a, long b) {
return b ? power(a * a % MOD, b / 2) * (b % 2 ? a : 1) % MOD : 1;
}
long perm(int N, int K) {
long x = 1;
for (int i = 1; i <= K; i++) {
x = x * (N - i + 1) % MOD;
}
return x % MOD;
}
long factorial(int N) { return perm(N, N); }
long comb(int N, int K) {
long x = 1, y = 1;
for (int i = 1; i <= K; i++) {
x = x * (N - i + 1) % MOD;
y = y * i % MOD;
}
return x * power(y, MOD - 2) % MOD;
}
long hcomb(int N, int K) { return comb(N + K - 1, N - 1); }
int dtoi(double d) {
if ((double)2 * d - floor(d) - ceil(d) >= 0)
return ceil(d);
else
return floor(d);
}
bool isprime(int n) {
if (n < 2)
return false;
for (int i = 2; i * i <= n; ++i) {
if (n % i == 0)
return false;
}
return true;
}
void eratosthenes(int n) {
// エラトステネスのふるい
bitset<1000000> is_prime(0); // 十分大きなサイズを確保します
for (int i = 2; i <= n; ++i)
is_prime.set(i); // とりあえず全部ふるいに入れます
for (int i = 2; i <= n; ++i) {
if (is_prime[i]) { // 素数 i を発見したら
for (int j = i * 2; j <= n; j += i) {
is_prime.reset(j); // i の倍数をふるい落とす
}
}
}
for (int i = 2; i <= n; ++i) {
if (is_prime[i])
cout << i << endl;
}
}
void dfs(const vector<vector<int>> &G, int v, vector<int> &seen) {
seen[v] = true; // v を訪問済にする
// v から行ける各頂点 next_v について
for (int next_v : G[v]) {
if (seen[next_v])
continue; // next_v が探索済だったらスルー
dfs(G, next_v, seen); // 再帰的に探索
}
}
void bfs(const vector<vector<int>> &G, int v, vector<int> &dist) {
REP(i, SZ(dist)) dist[i] = -1; // 全頂点を「未訪問」に初期化
queue<int> que;
// 初期条件 (頂点 0 を初期ノードとする)
dist[v] = 0;
que.push(v); // 0 を橙色頂点にする
// BFS 開始 (キューが空になるまで探索を行う)
while (!que.empty()) {
v = que.front(); // キューから先頭頂点を取り出す
que.pop();
// v から辿れる頂点をすべて調べる
for (int next_v : G[v]) {
if (dist[next_v] != -1)
continue; // すでに発見済みの頂点は探索しない
// 新たな白色頂点 nv について距離情報を更新してキューに追加する
dist[next_v] = dist[v] + 1;
que.push(next_v);
}
}
}
int knapsack01(int N, int W, vector<int> &value, vector<int> &weight) {
VVI dp(N + 1, VI(W + 1, 0));
REP(i, N) REP(j, W + 1) {
if (j - weight[i] >= 0)
dp[i + 1][j] = max(dp[i][j - weight[i]] + value[i], dp[i][j]);
else
dp[i + 1][j] = dp[i][j];
}
return dp[N][W];
}
int knapsack01_reuse(int N, int W, vector<int> &value, vector<int> &weight) {
VI dp(W + 1, 0);
dp[0] = 0;
for (int i = 0; i < N; i++) {
for (int j = W; j > 0; j--) {
if (j - weight[i] >= 0)
dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
}
}
return dp[W];
}
int knapsack(int N, int W, vector<int> &value, vector<int> &weight) {
VVI dp(N + 1, VI(W + 1, 0));
REP(i, N) REP(j, W + 1) {
dp[i + 1][j] = max(dp[i][j], dp[i + 1][j]);
if (j - weight[i] >= 0)
dp[i + 1][j] = max(dp[i + 1][j - weight[i]] + value[i], dp[i + 1][j]);
}
return dp[N][W];
}
int knapsack_reuse(int N, int W, vector<int> &value, vector<int> &weight) {
VI dp(W + 1, 0);
dp[0] = 0;
for (int i = 0; i < N; ++i) {
for (int w = weight[i]; w <= W; ++w) {
dp[w] = max(dp[w], dp[w - weight[i]] + value[i]);
}
}
return dp[W];
}
int lis(int n, vector<int> &A) {
vector<int> L(n + 1, 0);
L[0] = A[0];
int length = 1;
FOR(i, 1, n) {
if (L[length - 1] < A[i])
L[length++] = A[i];
else
*lower_bound(L.begin(), next(L.begin(), length), A[i]) = A[i];
}
return length;
}
int lcs(string X, string Y) {
int m = X.length();
int n = Y.length();
int res = 0;
X = ' ' + X;
Y = ' ' + Y;
VVI c(m + 1, VI(n + 1, 0));
FOR(i, 1, m + 1) FOR(j, 1, n + 1) {
if (X[i] == Y[j])
c[i][j] = c[i - 1][j - 1] + 1;
else
c[i][j] = max(c[i - 1][j], c[i][j - 1]);
res = max(res, c[i][j]);
}
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(10);
int N;
cin >> N;
VI h(N);
REP(i, N) cin >> h[i];
VI dp(N + 1, INF);
dp[0] = 0;
dp[1] = abs(h[1] - h[0]);
FOR(i, 2, N + 1) {
chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
cout << dp[N] << endl;
} | #include "bits/stdc++.h"
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, a, b) for (int i = (b)-1; i >= (a); --i)
#define ALL(v) v.begin(), v.end()
#define FS first
#define SC second
#define SZ(a) int((a).size())
#define SORT(c) sort((c).begin(), (c).end())
#define MEMSET(v, h) memset((v), h, sizeof(v))
#define SQR(x) ((x) * (x))
#define BIT(n) (1LL << (n))
#define PCNT(x) __builtin_popcountll(x)
#define PB push_back
#define MP make_pair
#define endl "\n"
using namespace std;
typedef long long LL;
typedef long double LD;
typedef vector<int> VI;
typedef vector<LL> VLL;
typedef vector<bool> VB;
typedef vector<vector<int>> VVI;
typedef vector<vector<bool>> VVB;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef vector<PII> VPII;
const LL MOD = 1000000007ll;
const LL INF = 2000000000ll;
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 dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
long power(long a, long b) {
return b ? power(a * a % MOD, b / 2) * (b % 2 ? a : 1) % MOD : 1;
}
long perm(int N, int K) {
long x = 1;
for (int i = 1; i <= K; i++) {
x = x * (N - i + 1) % MOD;
}
return x % MOD;
}
long factorial(int N) { return perm(N, N); }
long comb(int N, int K) {
long x = 1, y = 1;
for (int i = 1; i <= K; i++) {
x = x * (N - i + 1) % MOD;
y = y * i % MOD;
}
return x * power(y, MOD - 2) % MOD;
}
long hcomb(int N, int K) { return comb(N + K - 1, N - 1); }
int dtoi(double d) {
if ((double)2 * d - floor(d) - ceil(d) >= 0)
return ceil(d);
else
return floor(d);
}
bool isprime(int n) {
if (n < 2)
return false;
for (int i = 2; i * i <= n; ++i) {
if (n % i == 0)
return false;
}
return true;
}
void eratosthenes(int n) {
// エラトステネスのふるい
bitset<1000000> is_prime(0); // 十分大きなサイズを確保します
for (int i = 2; i <= n; ++i)
is_prime.set(i); // とりあえず全部ふるいに入れます
for (int i = 2; i <= n; ++i) {
if (is_prime[i]) { // 素数 i を発見したら
for (int j = i * 2; j <= n; j += i) {
is_prime.reset(j); // i の倍数をふるい落とす
}
}
}
for (int i = 2; i <= n; ++i) {
if (is_prime[i])
cout << i << endl;
}
}
void dfs(const vector<vector<int>> &G, int v, vector<int> &seen) {
seen[v] = true; // v を訪問済にする
// v から行ける各頂点 next_v について
for (int next_v : G[v]) {
if (seen[next_v])
continue; // next_v が探索済だったらスルー
dfs(G, next_v, seen); // 再帰的に探索
}
}
void bfs(const vector<vector<int>> &G, int v, vector<int> &dist) {
REP(i, SZ(dist)) dist[i] = -1; // 全頂点を「未訪問」に初期化
queue<int> que;
// 初期条件 (頂点 0 を初期ノードとする)
dist[v] = 0;
que.push(v); // 0 を橙色頂点にする
// BFS 開始 (キューが空になるまで探索を行う)
while (!que.empty()) {
v = que.front(); // キューから先頭頂点を取り出す
que.pop();
// v から辿れる頂点をすべて調べる
for (int next_v : G[v]) {
if (dist[next_v] != -1)
continue; // すでに発見済みの頂点は探索しない
// 新たな白色頂点 nv について距離情報を更新してキューに追加する
dist[next_v] = dist[v] + 1;
que.push(next_v);
}
}
}
int knapsack01(int N, int W, vector<int> &value, vector<int> &weight) {
VVI dp(N + 1, VI(W + 1, 0));
REP(i, N) REP(j, W + 1) {
if (j - weight[i] >= 0)
dp[i + 1][j] = max(dp[i][j - weight[i]] + value[i], dp[i][j]);
else
dp[i + 1][j] = dp[i][j];
}
return dp[N][W];
}
int knapsack01_reuse(int N, int W, vector<int> &value, vector<int> &weight) {
VI dp(W + 1, 0);
dp[0] = 0;
for (int i = 0; i < N; i++) {
for (int j = W; j > 0; j--) {
if (j - weight[i] >= 0)
dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
}
}
return dp[W];
}
int knapsack(int N, int W, vector<int> &value, vector<int> &weight) {
VVI dp(N + 1, VI(W + 1, 0));
REP(i, N) REP(j, W + 1) {
dp[i + 1][j] = max(dp[i][j], dp[i + 1][j]);
if (j - weight[i] >= 0)
dp[i + 1][j] = max(dp[i + 1][j - weight[i]] + value[i], dp[i + 1][j]);
}
return dp[N][W];
}
int knapsack_reuse(int N, int W, vector<int> &value, vector<int> &weight) {
VI dp(W + 1, 0);
dp[0] = 0;
for (int i = 0; i < N; ++i) {
for (int w = weight[i]; w <= W; ++w) {
dp[w] = max(dp[w], dp[w - weight[i]] + value[i]);
}
}
return dp[W];
}
int lis(int n, vector<int> &A) {
vector<int> L(n + 1, 0);
L[0] = A[0];
int length = 1;
FOR(i, 1, n) {
if (L[length - 1] < A[i])
L[length++] = A[i];
else
*lower_bound(L.begin(), next(L.begin(), length), A[i]) = A[i];
}
return length;
}
int lcs(string X, string Y) {
int m = X.length();
int n = Y.length();
int res = 0;
X = ' ' + X;
Y = ' ' + Y;
VVI c(m + 1, VI(n + 1, 0));
FOR(i, 1, m + 1) FOR(j, 1, n + 1) {
if (X[i] == Y[j])
c[i][j] = c[i - 1][j - 1] + 1;
else
c[i][j] = max(c[i - 1][j], c[i][j - 1]);
res = max(res, c[i][j]);
}
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(10);
int N;
cin >> N;
VI h(N);
REP(i, N) cin >> h[i];
VI dp(N, INF);
dp[0] = 0;
dp[1] = abs(h[1] - h[0]);
FOR(i, 2, N) {
chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
cout << dp[N - 1] << endl;
} | [
"expression.operation.binary.remove"
] | 954,280 | 954,281 | u313403396 | cpp |
p03160 | #include <bits/stdc++.h>
#define max 10004
using namespace std;
int main() {
long n, h[100005];
cin >> n;
for (long i = 0; i < n; i++)
cin >> h[i];
long dp[100005];
for (long i = 0; i < n; i++)
dp[i] = max;
dp[0] = 0;
dp[1] = dp[0] + abs(h[1] - h[0]);
for (long i = 2; i < n; i++) {
long val1 = dp[i - 1] + abs(h[i] - h[i - 1]);
long val2 = dp[i - 2] + abs(h[i] - h[i - 2]);
if (dp[i] > val1)
dp[i] = val1;
if (dp[i] > val2)
dp[i] = val2;
}
cout << dp[n - 1];
} | #include <bits/stdc++.h>
#define max 1000000009
using namespace std;
int main() {
long n, h[100005];
cin >> n;
for (long i = 0; i < n; i++)
cin >> h[i];
long dp[100005];
for (long i = 0; i < n; i++)
dp[i] = max;
dp[0] = 0;
dp[1] = dp[0] + abs(h[1] - h[0]);
for (long i = 2; i < n; i++) {
long val1 = dp[i - 1] + abs(h[i] - h[i - 1]);
long val2 = dp[i - 2] + abs(h[i] - h[i - 2]);
if (dp[i] > val1)
dp[i] = val1;
if (dp[i] > val2)
dp[i] = val2;
}
cout << dp[n - 1];
}
| [
"preprocessor.define.value.change",
"literal.integer.change"
] | 954,288 | 954,289 | u640930204 | cpp |
p03160 | // Resting_Prince
#include <bits/stdc++.h>
#define mod 1000000007
#define inf 1e18
#define PI 3.141592653589
#define fi first
#define se second
#define sv(v) \
sort(all(v)); \
reverse(all(v))
#define all(v) v.begin(), v.end()
#define rep(i, a, b) for (ll i = a; i <= b; i++)
#define repr(i, a, b) for (ll i = a; i >= b; i--)
#define pb push_back
#define mk make_pair
#define en '\n'
#define ios \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0)
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> pll;
typedef long double ld;
int main() {
ll n, h[100005], i, j, k, l, dp[100005] = {0};
cin >> n;
rep(i, 0, n - 1) cin >> h[i];
dp[0] = 0;
dp[1] = h[0];
dp[2] = abs(h[1] - h[0]);
rep(i, 1, n - 2) {
dp[i + 2] =
min(dp[i + 1] + abs(h[i + 1] - h[i]), dp[i] + abs(h[i + 1] - h[i - 1]));
}
cout << dp[n];
return 0;
}
| // Resting_Prince
#include <bits/stdc++.h>
#define mod 1000000007
#define inf 1e18
#define PI 3.141592653589
#define fi first
#define se second
#define sv(v) \
sort(all(v)); \
reverse(all(v))
#define all(v) v.begin(), v.end()
#define rep(i, a, b) for (ll i = a; i <= b; i++)
#define repr(i, a, b) for (ll i = a; i >= b; i--)
#define pb push_back
#define mk make_pair
#define en '\n'
#define ios \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0)
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> pll;
typedef long double ld;
int main() {
ll n, h[100005], i, j, k, l, dp[100005] = {0};
cin >> n;
rep(i, 0, n - 1) cin >> h[i];
dp[0] = 0;
dp[1] = 0;
dp[2] = abs(h[1] - h[0]);
rep(i, 1, n - 2) {
dp[i + 2] =
min(dp[i + 1] + abs(h[i + 1] - h[i]), dp[i] + abs(h[i + 1] - h[i - 1]));
}
cout << dp[n];
return 0;
}
| [] | 954,290 | 954,291 | u640930204 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int N;
cin >> N;
vector<int> h(N);
for (int i = 0; i < N; i++)
cin >> h[i];
vector<int> dp(100, 0);
dp[0] = 0;
dp[1] = dp[0] + 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;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int N;
cin >> N;
vector<int> h(N);
for (int i = 0; i < N; i++)
cin >> h[i];
vector<int> dp(100'000, 0);
dp[0] = 0;
dp[1] = dp[0] + abs(h[1] - h[0]);
for (int i = 2; i < N; i++) {
dp[i] +=
min(dp[i - 1] + abs(h[i] - h[i - 1]), dp[i - 2] + abs(h[i] - h[i - 2]));
}
cout << dp[N - 1] << endl;
}
| [
"literal.number.change",
"call.arguments.change"
] | 954,304 | 954,305 | u964763428 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
// 型名の省略
typedef unsigned int uint;
typedef long long lint;
typedef unsigned long long ulint;
const int MOD = 1000000007;
const lint INF = 1LL << 60;
const double PI = acos(-1.0);
// cinとcoutの高速化
#define endl "\n"
struct cinacc {
cinacc() {
cin.tie(0);
ios::sync_with_stdio(false);
}
} cinaccc;
struct coutacc {
coutacc() {
cout.setf(ios::fixed);
cout.precision(12);
}
} coutaccc;
// 繰り返し
#define rep(i, n) for (lint i = 0; i < (lint)(n); i++)
#define reps(i, n) for (lint i = 0; i <= (lint)(n); i++)
#define rrep(i, n) for (lint i = (lint)(n)-1; i > 0; i--)
#define rreps(i, n) for (lint i = (lint)(n)-1; i >= 0; i--)
#define pb push_back
#define p pair<int, int>
#define plint pair<lint, lint>
#define ALL(s) (s.begin(), s.end())
#define SZ(s) (s.size())
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
// Union-Find-Tree
class UnionFind {
vector<int> par;
UnionFind(int n) : par(n) { rep(i, n) par[i] = i; }
int root(int x) {
if (par[x] == x)
return x;
return par[x] = root(par[x]);
}
void unite(int x, int y) {
int rx = root(x);
int ry = root(y);
if (rx == ry)
return;
par[rx] = ry;
}
bool same(int x, int y) { return root(x) == root(y); }
};
// Final Weapon!
// #define int lint
#define MAX_N 100000
lint dp[MAX_N];
int main(void) {
int n;
cin >> n;
vector<int> h(n);
rep(i, n) cin >> h[i];
rep(i, n) dp[i] = INF;
dp[0] = 0;
for (int i = 2; i < n; i++) {
chmin(dp[i], dp[i - 1] + abs(h[i - 1] - h[i]));
if (i > 1)
chmin(dp[i], dp[i - 2] + abs(h[i - 2] - h[i]));
}
cout << dp[n - 1];
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
// 型名の省略
typedef unsigned int uint;
typedef long long lint;
typedef unsigned long long ulint;
const int MOD = 1000000007;
const lint INF = 1LL << 60;
const double PI = acos(-1.0);
// cinとcoutの高速化
#define endl "\n"
struct cinacc {
cinacc() {
cin.tie(0);
ios::sync_with_stdio(false);
}
} cinaccc;
struct coutacc {
coutacc() {
cout.setf(ios::fixed);
cout.precision(12);
}
} coutaccc;
// 繰り返し
#define rep(i, n) for (lint i = 0; i < (lint)(n); i++)
#define reps(i, n) for (lint i = 0; i <= (lint)(n); i++)
#define rrep(i, n) for (lint i = (lint)(n)-1; i > 0; i--)
#define rreps(i, n) for (lint i = (lint)(n)-1; i >= 0; i--)
#define pb push_back
#define p pair<int, int>
#define plint pair<lint, lint>
#define ALL(s) (s.begin(), s.end())
#define SZ(s) (s.size())
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
// Union-Find-Tree
class UnionFind {
vector<int> par;
UnionFind(int n) : par(n) { rep(i, n) par[i] = i; }
int root(int x) {
if (par[x] == x)
return x;
return par[x] = root(par[x]);
}
void unite(int x, int y) {
int rx = root(x);
int ry = root(y);
if (rx == ry)
return;
par[rx] = ry;
}
bool same(int x, int y) { return root(x) == root(y); }
};
// Final Weapon!
// #define int lint
#define MAX_N 100000
lint dp[MAX_N];
int main(void) {
int n;
cin >> n;
vector<int> h(n);
rep(i, n) cin >> h[i];
rep(i, n) dp[i] = INF;
dp[0] = 0;
for (int i = 1; i < n; i++) {
chmin(dp[i], dp[i - 1] + abs(h[i - 1] - h[i]));
if (i > 1)
chmin(dp[i], dp[i - 2] + abs(h[i - 2] - h[i]));
}
cout << dp[n - 1];
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 954,306 | 954,307 | u460426711 | cpp |
p03160 | #include <algorithm>
#include <bitset>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long double ld;
typedef long long int ll;
typedef unsigned long long int ull;
typedef vector<int> vi;
typedef vector<char> vc;
typedef vector<string> vs;
typedef vector<pair<int, int>> vpii;
typedef vector<vector<int>> vvi;
typedef vector<vector<char>> vvc;
typedef vector<vector<string>> vvs;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define fin(ans) cout << (ans) << endl
#define P 1000000007
#define STI(s) atoi(s.c_str()) // string to int
#define mp(p, q) make_pair(p, q)
#define pb(n) push_back(n)
#define Sort(a) sort(a.begin(), a.end())
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 int INF = INT_MAX;
const long long LLINF = 1LL << 60;
// g++ -std=c++1z temp.cpp
//./a.out
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
//////////////////////////////////////////////////////
int n;
cin >> n;
vector<ll> h(n + 1), dp(n + 1, INF);
rep(i, n) cin >> h[i + 1];
dp[0] = 0;
dp[1] = 0;
for (int i = 2; i <= n; i++) {
// cout<<dp[i]<<" "<<abs(h[i]-h[i-1])<<endl;
chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
// cout<<dp[i]<<endl;
}
cout << dp[n] << endl;
//////////////////////////////////////////////////////
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long double ld;
typedef long long int ll;
typedef unsigned long long int ull;
typedef vector<int> vi;
typedef vector<char> vc;
typedef vector<string> vs;
typedef vector<pair<int, int>> vpii;
typedef vector<vector<int>> vvi;
typedef vector<vector<char>> vvc;
typedef vector<vector<string>> vvs;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define fin(ans) cout << (ans) << endl
#define P 1000000007
#define STI(s) atoi(s.c_str()) // string to int
#define mp(p, q) make_pair(p, q)
#define pb(n) push_back(n)
#define Sort(a) sort(a.begin(), a.end())
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 int INF = INT_MAX;
const long long LLINF = 1LL << 60;
// g++ -std=c++1z temp.cpp
//./a.out
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
//////////////////////////////////////////////////////
int n;
cin >> n;
vector<ll> h(n + 1), dp(n + 1, INF);
rep(i, n) cin >> h[i + 1];
dp[0] = 1000000;
dp[1] = 0;
for (int i = 2; i <= n; i++) {
// cout<<dp[i]<<" "<<abs(h[i]-h[i-1])<<endl;
chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
// cout<<dp[i]<<endl;
}
cout << dp[n] << endl;
//////////////////////////////////////////////////////
return 0;
}
| [
"literal.number.change",
"assignment.value.change"
] | 954,310 | 954,311 | u903311413 | cpp |
p03160 | #include <algorithm>
#include <bitset>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long double ld;
typedef long long int ll;
typedef unsigned long long int ull;
typedef vector<int> vi;
typedef vector<char> vc;
typedef vector<string> vs;
typedef vector<pair<int, int>> vpii;
typedef vector<vector<int>> vvi;
typedef vector<vector<char>> vvc;
typedef vector<vector<string>> vvs;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define fin(ans) cout << (ans) << endl
#define P 1000000007
#define STI(s) atoi(s.c_str()) // string to int
#define mp(p, q) make_pair(p, q)
#define pb(n) push_back(n)
#define Sort(a) sort(a.begin(), a.end())
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 int INF = INT_MAX;
const long long LLINF = 1LL << 60;
// g++ -std=c++1z temp.cpp
//./a.out
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
//////////////////////////////////////////////////////
int n;
cin >> n;
vi h(n + 1), dp(n + 1, INF);
rep(i, n) cin >> h[i + 1];
dp[0] = 0;
dp[1] = 0;
for (int i = 2; i <= n; i++) {
// cout<<dp[i]<<" "<<abs(h[i]-h[i-1])<<endl;
chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
// cout<<dp[i]<<endl;
}
cout << dp[n] << endl;
//////////////////////////////////////////////////////
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long double ld;
typedef long long int ll;
typedef unsigned long long int ull;
typedef vector<int> vi;
typedef vector<char> vc;
typedef vector<string> vs;
typedef vector<pair<int, int>> vpii;
typedef vector<vector<int>> vvi;
typedef vector<vector<char>> vvc;
typedef vector<vector<string>> vvs;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define fin(ans) cout << (ans) << endl
#define P 1000000007
#define STI(s) atoi(s.c_str()) // string to int
#define mp(p, q) make_pair(p, q)
#define pb(n) push_back(n)
#define Sort(a) sort(a.begin(), a.end())
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 int INF = INT_MAX;
const long long LLINF = 1LL << 60;
// g++ -std=c++1z temp.cpp
//./a.out
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
//////////////////////////////////////////////////////
int n;
cin >> n;
vector<ll> h(n + 1), dp(n + 1, INF);
rep(i, n) cin >> h[i + 1];
dp[0] = 1000000;
dp[1] = 0;
for (int i = 2; i <= n; i++) {
// cout<<dp[i]<<" "<<abs(h[i]-h[i-1])<<endl;
chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
// cout<<dp[i]<<endl;
}
cout << dp[n] << endl;
//////////////////////////////////////////////////////
return 0;
}
| [
"variable_declaration.type.change",
"literal.number.change",
"assignment.value.change"
] | 954,312 | 954,311 | u903311413 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n == 1) {
cout << 0 << endl;
return 0;
}
int a[1000000];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int dp[1000000];
dp[0] = 0;
dp[1] = a[1] - a[0];
for (int i = 2; i < n; i++) {
dp[i] = min((dp[i - 1] + abs(a[i] - a[i - 1])),
(dp[i - 2] + abs(a[i] - a[i - 2])));
}
cout << dp[n - 1] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n == 1) {
cout << 0 << endl;
return 0;
}
int a[1000000];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int dp[1000000];
dp[0] = 0;
dp[1] = abs(a[1] - a[0]);
for (int i = 2; i < n; i++) {
dp[i] = min((dp[i - 1] + abs(a[i] - a[i - 1])),
(dp[i - 2] + abs(a[i] - a[i - 2])));
}
cout << dp[n - 1] << endl;
return 0;
} | [
"call.add",
"call.arguments.change"
] | 954,316 | 954,317 | u652064866 | cpp |
p03160 | #include <bits/stdc++.h>
#define rep(i, a) for (int i = 0; i < a; i++)
#define rep1(i, a, b) for (int i = a; i < b; i++)
using ll = long long;
using namespace std;
int main() {
int n;
cin >> n;
vector<ll> v(n), dp(n);
rep(i, n) cin >> v[i];
dp[0] = v[0];
dp[1] = abs(v[1] - v[0]);
rep1(i, 2, n) dp[i] =
min(dp[i - 1] + abs(v[i] - v[i - 1]), dp[i - 2] + abs(v[i] - v[i - 2]));
cout << dp[n - 1] << endl;
} | #include <bits/stdc++.h>
#define rep(i, a) for (int i = 0; i < a; i++)
#define rep1(i, a, b) for (int i = a; i < b; i++)
using ll = long long;
using namespace std;
int main() {
int n;
cin >> n;
vector<ll> v(n), dp(n);
rep(i, n) cin >> v[i];
dp[0] = 0;
dp[1] = abs(v[1] - v[0]);
rep1(i, 2, n) dp[i] =
min(dp[i - 1] + abs(v[i] - v[i - 1]), dp[i - 2] + abs(v[i] - v[i - 2]));
cout << dp[n - 1] << endl;
} | [] | 954,322 | 954,323 | u624118226 | 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;
int main() {
int N;
cin >> N;
vector<int64_t> h(N + 1), dp(N + 1);
for (int i = 1; i <= N; i++) {
cin >> h[i];
}
for (int i = 0; i <= N; i++) {
dp[i] = 1000000;
}
dp[1] = 0;
for (int i = 2; i <= N; i++) {
chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
cout << dp[N] << endl;
} | #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;
int main() {
int N;
cin >> N;
vector<long long> h(N + 1), dp(N + 1);
for (int i = 1; i <= N; i++) {
cin >> h[i];
}
for (int i = 0; i <= N; i++) {
dp[i] = INF;
}
dp[1] = 0;
for (int i = 2; i <= N; i++) {
chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
cout << dp[N] << endl;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 954,328 | 954,329 | u265359795 | 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;
int main() {
int N;
cin >> N;
vector<int> h(N + 1), dp(N + 1);
for (int i = 1; i <= N; i++) {
cin >> h[i];
}
for (int i = 0; i <= N; i++) {
dp[i] = 1000000;
}
dp[1] = 0;
for (int i = 2; i <= N; i++) {
chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
cout << dp[N] << endl;
} | #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;
int main() {
int N;
cin >> N;
vector<long long> h(N + 1), dp(N + 1);
for (int i = 1; i <= N; i++) {
cin >> h[i];
}
for (int i = 0; i <= N; i++) {
dp[i] = INF;
}
dp[1] = 0;
for (int i = 2; i <= N; i++) {
chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
cout << dp[N] << endl;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 954,330 | 954,329 | u265359795 | cpp |
p03160 | #include <iostream>
#include <vector>
#define rep(i, x) for (int i = 0; i < x; i++)
using ll = long long;
using namespace std;
int INF = 100100;
int main() {
int n;
cin >> n;
vector<int> h(n);
rep(i, n) cin >> h[i];
h.push_back(INF);
h.push_back(INF);
vector<int> dp(n + 10, INF); //余裕をもって要素数+10
dp[0] = 0;
rep(i, n) {
int nh1 = i + 1;
int nh2 = i + 2;
dp[nh1] = min(dp[nh1], dp[i] + abs(h[nh1] - h[i]));
dp[nh2] = min(dp[nh2], dp[i] + abs(h[nh2] - h[i]));
}
cout << dp[n - 1] << endl;
}
| #include <iostream>
#include <vector>
#define rep(i, x) for (int i = 0; i < x; i++)
using ll = long long;
using namespace std;
int INF = 1001001001;
int main() {
int n;
cin >> n;
vector<int> h(n);
rep(i, n) cin >> h[i];
h.push_back(INF);
h.push_back(INF);
vector<int> dp(n + 10, INF); //余裕をもって要素数+10
dp[0] = 0;
rep(i, n) {
int nh1 = i + 1;
int nh2 = i + 2;
dp[nh1] = min(dp[nh1], dp[i] + abs(h[nh1] - h[i]));
dp[nh2] = min(dp[nh2], dp[i] + abs(h[nh2] - h[i]));
}
cout << dp[n - 1] << endl;
}
| [
"literal.number.change",
"variable_declaration.value.change"
] | 954,344 | 954,345 | u580923688 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int h[n];
int post[n];
for (int i = 0; i < n; i++)
scanf("%d", &h[i]);
post[0] = h[0];
post[1] = abs(h[0] - h[1]);
for (int j = 2; j < n; j++) {
post[j] = min(post[j - 1] + abs(h[j - 1] - h[j]),
post[j - 2] + abs(h[j - 2] - h[j]));
}
printf("%d", post[n]);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int h[n];
int post[n];
for (int i = 0; i < n; i++)
scanf("%d", &h[i]);
post[0] = 0;
post[1] = abs(h[0] - h[1]);
for (int j = 2; j < n; j++) {
post[j] = min(post[j - 1] + abs(h[j - 1] - h[j]),
post[j - 2] + abs(h[j - 2] - h[j]));
}
printf("%d", post[n - 1]);
return 0;
} | [
"expression.operation.binary.add"
] | 954,348 | 954,349 | u379682992 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define IO \
ios_base::sync_with_stdio(0); \
cin.tie(0)
#define F first
#define S second
#define pb push_back
#define all(x) (x).begin(), (x).end()
typedef long long ll;
typedef pair<int, int> pii;
int main() {
IO;
int n;
cin >> n;
vector<int> v(n + 3);
for (int i = 1; i <= n; i++)
cin >> v[i];
vector<int> dp(n + 3, 1e9);
dp[1] = 0;
for (int i = 1; i < n; i++) {
dp[i + 1] = min(dp[i + 1], dp[i] + abs(v[i + 1] - v[i]));
dp[i + 2] = min(dp[i + 2], dp[i] + abs(v[i + 1] - v[i]));
}
cout << dp[n] << "\n";
} | #include <bits/stdc++.h>
using namespace std;
#define IO \
ios_base::sync_with_stdio(0); \
cin.tie(0)
#define F first
#define S second
#define pb push_back
#define all(x) (x).begin(), (x).end()
typedef long long ll;
typedef pair<int, int> pii;
int main() {
IO;
int n;
cin >> n;
vector<int> v(n + 3);
for (int i = 1; i <= n; i++)
cin >> v[i];
vector<int> dp(n + 3, 1e9);
dp[1] = 0;
for (int i = 1; i < n; i++) {
dp[i + 1] = min(dp[i + 1], dp[i] + abs(v[i + 1] - v[i]));
dp[i + 2] = min(dp[i + 2], dp[i] + abs(v[i + 2] - v[i]));
}
cout << dp[n] << "\n";
} | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 954,350 | 954,351 | u801891559 | cpp |
p03160 | #include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#define rep(i, n) for (int(i) = 0; (i) < (n); ++(i))
#define _Pi 3.1415926535
#define _MOD = 1e9 + 7;
using namespace std;
typedef long long ll;
int main() {
int n;
cin >> n;
vector<int> h(n);
rep(i, n) cin >> h[i];
vector<int> cost(n);
cost[0] = 0;
cost[1] = abs(h[1] - h[0]);
for (int i = 1; i < n; ++i) {
cost[i] = min(cost[i - 1] + abs(h[i] - h[i - 1]),
cost[i - 2] + abs(h[i] - h[i - 2]));
}
cout << cost[n - 1] << endl;
return 0;
}
| #include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#define rep(i, n) for (int(i) = 0; (i) < (n); ++(i))
#define _Pi 3.1415926535
#define _MOD = 1e9 + 7;
using namespace std;
typedef long long ll;
int main() {
int n;
cin >> n;
vector<int> h(n);
rep(i, n) cin >> h[i];
vector<int> cost(n);
cost[0] = 0;
cost[1] = abs(h[1] - h[0]);
for (int i = 2; i < n; ++i) {
cost[i] = min(cost[i - 1] + abs(h[i] - h[i - 1]),
cost[i - 2] + abs(h[i] - h[i - 2]));
}
cout << cost[n - 1] << endl;
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 954,352 | 954,353 | u445457059 | cpp |
p03160 | #include <iostream>
using namespace std;
int n;
int dp[100005];
int mincost(int a[]) {
dp[0] = a[0];
dp[1] = abs(a[1] - a[0]);
dp[2] = min(dp[1] + abs(a[1] - a[0]), abs(a[1] - a[0]));
for (int i = 3; i < n; i++) {
dp[i] =
min(dp[i - 2] + abs(a[i] - a[i - 2]), dp[i - 1] + abs(a[i] - a[i - 1]));
}
return dp[n - 1];
}
int main() {
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int ans = mincost(a);
cout << ans;
} | #include <iostream>
using namespace std;
int n;
int dp[100005];
int mincost(int a[]) {
dp[0] = a[0];
dp[1] = abs(a[1] - a[0]);
dp[2] = min(dp[1] + abs(a[2] - a[1]), abs(a[2] - a[0]));
for (int i = 3; i < n; i++) {
dp[i] =
min(dp[i - 2] + abs(a[i] - a[i - 2]), dp[i - 1] + abs(a[i] - a[i - 1]));
}
return dp[n - 1];
}
int main() {
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int ans = mincost(a);
cout << ans;
} | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 954,356 | 954,357 | u186401165 | cpp |
p03160 | #include <bits/stdc++.h>
#define FAST_IO \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define INF (1e10 + 5)
#define F first
#define S second
#define pb push_back
#define MP make_pair
#define FRL(i, a, n) for (i = a; i < n; i++)
#define FR(i, n) FRL(i, 0, n)
#define RFRL(i, n) for (i = n; i >= 0; i--)
#define MOD 1000000007
#define fill(a) memset(dp, a, sizeof(dp));
using namespace std;
typedef long long int ll;
typedef vector<ll> vi;
typedef pair<ll, ll> pi;
typedef vector<pair<ll, ll>> vpi;
typedef set<ll> st;
typedef map<ll, ll> mp;
typedef unordered_map<ll, ll> ump;
template <class T> T minn(T a, T b) { return (a > b) ? b : a; }
template <class T> T maxx(T a, T b) { return (a > b) ? a : b; }
void FILE_OP() {
#ifndef ONLINE_JUDGE
freopen("inputf.txt", "r", stdin);
freopen("output2.txt", "w", stdout);
#endif
}
ll binpow(ll a, ll b) {
ll res = 1;
while (b > 0) {
if (b & 1)
res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
ll n;
vi v(100005);
ll dp[100005];
/*ll frog(ll i,ll c)
{
if(i>n)
return 0;
c=c+minn(frog(i+1,abs(v[i-1]-v[i])),frog(i+2,abs(v[i-2]-v[i])));
return c;
}*/
void SOLVE() {
ll tt, m, i, j, k, a, b, c, d, l, r;
// cin>>tt;
tt = 1;
fill(0) while (tt--) {
cin >> n;
FR(i, n)
cin >> v[i];
dp[0] = 0;
dp[1] = abs(v[1] - v[0]);
for (i = 2; i < n; i++) {
dp[i] += minn(dp[i - 1] + abs(v[i] - v[i - 1]),
dp[i - 2] + abs(v[i] - v[i - 2]));
}
cout << dp[n - 1];
}
}
int main() {
FAST_IO
FILE_OP();
SOLVE();
return 0;
} | #include <bits/stdc++.h>
#define FAST_IO \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define INF (1e10 + 5)
#define F first
#define S second
#define pb push_back
#define MP make_pair
#define FRL(i, a, n) for (i = a; i < n; i++)
#define FR(i, n) FRL(i, 0, n)
#define RFRL(i, n) for (i = n; i >= 0; i--)
#define MOD 1000000007
#define fill(a) memset(dp, a, sizeof(dp));
using namespace std;
typedef long long int ll;
typedef vector<ll> vi;
typedef pair<ll, ll> pi;
typedef vector<pair<ll, ll>> vpi;
typedef set<ll> st;
typedef map<ll, ll> mp;
typedef unordered_map<ll, ll> ump;
template <class T> T minn(T a, T b) { return (a > b) ? b : a; }
template <class T> T maxx(T a, T b) { return (a > b) ? a : b; }
void FILE_OP() {
#ifndef ONLINE_JUDGE
freopen("inputf.txt", "r", stdin);
freopen("output2.txt", "w", stdout);
#endif
}
ll binpow(ll a, ll b) {
ll res = 1;
while (b > 0) {
if (b & 1)
res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
ll n;
vi v(100005);
ll dp[100005];
/*ll frog(ll i,ll c)
{
if(i>n)
return 0;
c=c+minn(frog(i+1,abs(v[i-1]-v[i])),frog(i+2,abs(v[i-2]-v[i])));
return c;
}*/
void SOLVE() {
ll tt, m, i, j, k, a, b, c, d, l, r;
// cin>>tt;
tt = 1;
fill(0) while (tt--) {
cin >> n;
FR(i, n)
cin >> v[i];
dp[0] = 0;
dp[1] = abs(v[1] - v[0]);
for (i = 2; i < n; i++) {
dp[i] += minn(dp[i - 1] + abs(v[i] - v[i - 1]),
dp[i - 2] + abs(v[i] - v[i - 2]));
}
cout << dp[n - 1];
}
}
int main() {
FAST_IO
// FILE_OP();
SOLVE();
return 0;
} | [
"variable_declaration.remove"
] | 954,363 | 954,364 | u635116981 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cout.tie(0);
cin.tie(NULL);
int n;
cin >> n;
int h[n];
for (int i = 0; i < n; i++)
cin >> h[i];
int dp[n][2];
dp[0][0] = dp[0][1] = 0;
dp[1][0] = h[1] - h[0];
dp[1][1] = 10000001;
for (int i = 2; i < n; i++) {
dp[i][0] = min(dp[i - 1][0], dp[i - 1][1]) + abs(h[i] - h[i - 1]);
dp[i][1] = min(dp[i - 2][0], dp[i - 2][1]) + abs(h[i] - h[i - 2]);
}
cout << min(dp[n - 1][0], dp[n - 1][1]);
} | #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cout.tie(0);
cin.tie(NULL);
int n;
cin >> n;
int h[n];
for (int i = 0; i < n; i++)
cin >> h[i];
int dp[n][2];
dp[0][0] = dp[0][1] = 0;
dp[1][0] = abs(h[1] - h[0]);
dp[1][1] = 10000001;
for (int i = 2; i < n; i++) {
dp[i][0] = min(dp[i - 1][0], dp[i - 1][1]) + abs(h[i] - h[i - 1]);
dp[i][1] = min(dp[i - 2][0], dp[i - 2][1]) + abs(h[i] - h[i - 2]);
}
cout << min(dp[n - 1][0], dp[n - 1][1]);
} | [
"call.add",
"call.arguments.change"
] | 954,369 | 954,370 | u675879758 | cpp |
p03160 | #include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define mp make_pair
#define pll pair<ll, ll>
using namespace std;
const int maxn = 100100;
ll dp[maxn], h[maxn], n;
int main() {
cin >> n;
cin >> h[1];
for (int i = 2; i <= n; i++) {
cin >> h[i];
if (i == 2)
dp[i] = abs(h[2] - h[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";
} | #include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define mp make_pair
#define pll pair<ll, ll>
using namespace std;
const int maxn = 100100;
ll dp[maxn], h[maxn], n;
int main() {
cin >> n;
cin >> h[1];
for (int i = 2; i <= n; i++) {
cin >> h[i];
if (i == 2)
dp[i] = abs(h[2] - h[1]);
else
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";
} | [
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add"
] | 954,371 | 954,372 | u356738755 | cpp |
p03160 | // THIS IS MY NINJA WAY
#include <algorithm>
#include <bits/stdc++.h>
#include <ctime>
#include <vector>
#define str string
#define dbl double
#define ll long long
#define vl vector<ll>
#define vs vector<str>
#define pll pair<ll, ll>
#define vll vector<pll>
#define sl set<ll>
#define pb push_back
#define mp make_pair
#define ub upper_bound
#define lb lower_bound
#define ff first
#define ss second
#define fast \
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0); \
srand(time(NULL));
#define fr(i, a, b) for (long long i = a; i < b; i++)
#define nfr(i, a, b) for (long long i = a; i <= b; i++)
#define psl pair<str, ll>
#define pls pair<ll, str>
#define pss pair<str, str>
#define ALL(a) a.begin(), a.end()
#define stl stack<ll>
#define coml complex<ll>
#define INF 0x3f3f3f3f3f3f3f3f
#define max3(a, b, c) max(a, max(b, c))
#define min3(a, b, c) min(a, min(b, c))
const ll MOD = 1e9 + 7;
using namespace std;
int main() {
fast
//#ifndef ONLINE_JUDGE
// freopen("input.txt", "r" , stdin);
// freopen("output.txt", "w" , stdout);
//#endif
ll n;
cin >> n;
vl v(n);
fr(i, 0, n) cin >> v[i];
vl dp(n, INF); // as we want minimum number thus setting all to infinity
dp[0];
dp[1] = abs(v[1] - v[0]);
fr(i, 2, n) {
dp[i] =
min(dp[i - 1] + abs(v[i] - v[i - 1]), dp[i - 2] + abs(v[i] - v[i - 2]));
}
cout << dp[n - 1];
return 0;
}
| // THIS IS MY NINJA WAY
#include <algorithm>
#include <bits/stdc++.h>
#include <ctime>
#include <vector>
#define str string
#define dbl double
#define ll long long
#define vl vector<ll>
#define vs vector<str>
#define pll pair<ll, ll>
#define vll vector<pll>
#define sl set<ll>
#define pb push_back
#define mp make_pair
#define ub upper_bound
#define lb lower_bound
#define ff first
#define ss second
#define fast \
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0); \
srand(time(NULL));
#define fr(i, a, b) for (long long i = a; i < b; i++)
#define nfr(i, a, b) for (long long i = a; i <= b; i++)
#define psl pair<str, ll>
#define pls pair<ll, str>
#define pss pair<str, str>
#define ALL(a) a.begin(), a.end()
#define stl stack<ll>
#define coml complex<ll>
#define INF 0x3f3f3f3f3f3f3f3f
#define max3(a, b, c) max(a, max(b, c))
#define min3(a, b, c) min(a, min(b, c))
const ll MOD = 1e9 + 7;
using namespace std;
int main() {
fast
/*#ifndef ONLINE_JUDGE
freopen("input.txt", "r" , stdin);
freopen("output.txt", "w" , stdout);
#endif*/
ll n;
cin >> n;
vl v(n);
fr(i, 0, n) cin >> v[i];
vl dp(n); // as we want minimum number thus setting all to infinity
dp[0];
dp[1] = abs(v[1] - v[0]);
fr(i, 2, n) {
dp[i] =
min(dp[i - 1] + abs(v[i] - v[i - 1]), dp[i - 2] + abs(v[i] - v[i - 2]));
}
cout << dp[n - 1];
return 0;
}
| [] | 954,373 | 954,374 | u430369139 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
cin >> n;
vector<int> h(n);
vector<int> dp(n);
for (int i = 0; i < n; i++)
cin >> h[i];
dp[0] = 0;
for (int i = 1; i < n; i++)
dp[i] = 10000;
for (int i = 0; i < n; i++)
for (int j = i; j < min(n, i + 3); j++)
dp[j] = min(dp[j], dp[i] + abs(h[j] - h[i]));
cout << dp[n - 1] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
cin >> n;
vector<int> h(n);
vector<int> dp(n);
for (int i = 0; i < n; i++)
cin >> h[i];
dp[0] = 0;
for (int i = 1; i < n; i++)
dp[i] = INT32_MAX;
for (int i = 0; i < n; i++)
for (int j = i; j < min(n, i + 3); j++)
dp[j] = min(dp[j], dp[i] + abs(h[j] - h[i]));
cout << dp[n - 1] << endl;
return 0;
}
| [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 954,375 | 954,376 | u185967517 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int dp[n];
int arr[n];
for (int i = 0; i < n; ++i)
cin >> arr[i];
dp[0] = 0;
dp[1] = abs(arr[1] - arr[0]);
for (int i = 2; i < n; ++i) {
dp[i] = max(dp[i - 2] + abs(arr[i - 2] - arr[i]),
dp[i - 1] + abs(arr[i] - arr[i - 1]));
// dp[i]=max(dp[i],arr[i]);
}
cout << dp[n - 1];
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int dp[n];
int arr[n];
for (int i = 0; i < n; ++i)
cin >> arr[i];
dp[0] = 0;
dp[1] = abs(arr[1] - arr[0]);
for (int i = 2; i < n; ++i) {
dp[i] = min(dp[i - 2] + abs(arr[i - 2] - arr[i]),
dp[i - 1] + abs(arr[i] - arr[i - 1]));
// dp[i]=min(dp[i],arr[i]);
}
cout << dp[n - 1];
} | [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 954,383 | 954,384 | u012046378 | cpp |
p03160 | #include <bits/stdc++.h>
#define INF 1000000
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++)
cin >> arr[i];
vector<int> dp(n, INF);
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j <= i + 2; j++) {
if (j < n) {
dp[j] = min(dp[j], dp[i] + abs(arr[i] - arr[j]));
}
}
}
cout << dp[n - 1] << endl;
return 0;
}
| #include <bits/stdc++.h>
#define INF 1e9 + 5
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++)
cin >> arr[i];
vector<int> dp(n, INF);
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j <= i + 2; j++) {
if (j < n) {
dp[j] = min(dp[j], dp[i] + abs(arr[i] - arr[j]));
}
}
}
cout << dp[n - 1] << endl;
return 0;
}
| [
"preprocessor.define.value.change",
"literal.float.change"
] | 954,388 | 954,389 | u643712096 | cpp |
p03160 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
// ****************************************CODE***************************************//
ll n, h[100100];
ll dp[100100];
int main() {
cin >> n;
for (int i = 0; i < n; i++)
cin >> h[i];
for (int i = 0; i < 100100; i++)
dp[i] = inf;
dp[0] = 0;
for (int i = 0; i < n; i++) {
dp[i + 1] = max(dp[i + 1], dp[i] + abs(h[i] - h[i + 1]));
dp[i + 2] = max(dp[i + 2], dp[i] + abs(h[i] - h[i + 2]));
}
cout << dp[n - 1] << endl;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
// ****************************************CODE***************************************//
ll n, h[100100];
ll dp[100100];
int main() {
cin >> n;
for (int i = 0; i < n; i++)
cin >> h[i];
for (int i = 0; i < 100100; i++)
dp[i] = inf;
dp[0] = 0;
for (int i = 0; i < n; i++) {
dp[i + 1] = min(dp[i + 1], dp[i] + abs(h[i] - h[i + 1]));
dp[i + 2] = min(dp[i + 2], dp[i] + abs(h[i] - h[i + 2]));
}
cout << dp[n - 1] << endl;
}
| [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 954,390 | 954,391 | u195054737 | cpp |
p03160 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
// ****************************************CODE***************************************//
ll n;
ll h[100100];
ll dp[100100];
int main() {
cin >> n;
for (int i = 0; i < n; i++)
cin >> h[i];
for (int i = 0; i < 100100; i++)
dp[i] = inf;
dp[0] = 0;
for (int i = 0; i < n; i++) {
dp[i + 1] = min(dp[i + 1], dp[i] + abs(h[i] - h[i - 1]));
dp[i + 2] = min(dp[i + 2], dp[i] + abs(h[i] - h[i - 2]));
}
cout << dp[n - 1] << endl;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
// ****************************************CODE***************************************//
ll n, h[100100];
ll dp[100100];
int main() {
cin >> n;
for (int i = 0; i < n; i++)
cin >> h[i];
for (int i = 0; i < 100100; i++)
dp[i] = inf;
dp[0] = 0;
for (int i = 0; i < n; i++) {
dp[i + 1] = min(dp[i + 1], dp[i] + abs(h[i] - h[i + 1]));
dp[i + 2] = min(dp[i + 2], dp[i] + abs(h[i] - h[i + 2]));
}
cout << dp[n - 1] << endl;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 954,393 | 954,391 | u195054737 | cpp |
p03160 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
// ****************************************CODE***************************************//
ll n, h[100100];
ll dp[100100];
ll rec(ll i) {
if (dp[i] != inf)
return dp[i];
if (i == 0)
return 0;
ll res = 0;
res = min(res, rec(i - 1) + abs(h[i] - h[i - 1]));
if (i > 1)
res = min(res, rec(i - 2) + abs(h[i] - h[i - 2]));
return dp[i] = res;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++)
cin >> h[i];
for (int i = 0; i < 100100; i++)
dp[i] = inf;
dp[0] = 0;
cout << rec(n - 1) << endl;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
// ****************************************CODE***************************************//
ll n, h[100100];
ll dp[100100];
ll rec(ll i) {
if (dp[i] != inf)
return dp[i];
if (i == 0)
return 0;
ll res = inf;
res = min(res, rec(i - 1) + abs(h[i] - h[i - 1]));
if (i > 1)
res = min(res, rec(i - 2) + abs(h[i] - h[i - 2]));
return dp[i] = res;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++)
cin >> h[i];
for (int i = 0; i < 100100; i++)
dp[i] = inf;
dp[0] = 0;
cout << rec(n - 1) << endl;
} | [
"variable_declaration.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 954,394 | 954,395 | u195054737 | cpp |
p03160 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
// ****************************************CODE***************************************//
ll n;
ll h[100100];
ll dp[100100];
int main() {
cin >> n;
for (int i = 0; i < n; i++)
cin >> h[i];
for (int i = 0; i < 100100; i++)
dp[i] = inf;
dp[0] = 0;
for (int i = 0; i < n; i++) {
dp[i + 1] = min(dp[i + 1], dp[i] + abs(h[i] - h[i - 1]));
dp[i + 2] = min(dp[i + 2], dp[i] + abs(h[i] - h[i - 2]));
}
cout << dp[n - 1] << endl;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
// ****************************************CODE***************************************//
ll n, h[100100];
ll dp[100100];
int main() {
cin >> n;
for (int i = 0; i < n; i++)
cin >> h[i];
for (int i = 0; i < 100100; i++)
dp[i] = inf;
dp[0] = 0;
for (int i = 0; i < n; i++) {
dp[i + 1] = min(dp[i + 1], dp[i] + abs(h[i] - h[i + 1]));
dp[i + 2] = min(dp[i + 2], dp[i] + abs(h[i] - h[i + 2]));
}
cout << dp[n - 1] << endl;
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 954,393 | 954,396 | u195054737 | cpp |
p03160 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
// ****************************************CODE***************************************//
ll n;
ll h[100100];
ll dp[100100];
int main() {
cin >> n;
for (int i = 0; i < n; i++)
cin >> h[i];
for (int i = 0; i < 100100; i++)
dp[i] = inf;
dp[0] = 0;
for (int i = 0; i < n; i++) {
dp[i + 1] = min(dp[i + 1], dp[i] + abs(h[i] - h[i - 1]));
dp[i + 2] = min(dp[i + 2], dp[i] + abs(h[i] - h[i - 2]));
}
cout << dp[n - 1] << endl;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
// ****************************************CODE***************************************//
ll n, h[100100], dp[100100];
int main() {
cin >> n;
for (int i = 0; i < n; i++)
cin >> h[i];
for (int i = 0; i < 100100; i++)
dp[i] = inf;
dp[0] = 0;
for (int i = 0; i < n; i++) {
dp[i + 1] = min(dp[i + 1], dp[i] + abs(h[i] - h[i + 1]));
dp[i + 2] = min(dp[i + 2], dp[i] + abs(h[i] - h[i + 2]));
}
cout << dp[n - 1] << endl;
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 954,393 | 954,397 | u195054737 | cpp |
p03160 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
// ****************************************CODE***************************************//
ll n, h[100100];
ll dp[100100];
ll rec(ll i) {
if (dp[i] != inf)
return dp[i];
if (i == 0)
return 0;
ll res = 0;
res = min(res, rec(i - 1) + abs(h[i] - h[i - 1]));
if (i > 1)
res = min(res, rec(i - 2) + abs(h[i] - h[i - 2]));
return dp[i] = res;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++)
cin >> h[i];
for (int i = 0; i < 100100; i++)
dp[i] = inf;
cout << rec(n - 1) << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
// ****************************************CODE***************************************//
ll n, h[100100];
ll dp[100100];
ll rec(ll i) {
if (dp[i] != inf)
return dp[i];
if (i == 0)
return 0;
ll res = inf;
res = min(res, rec(i - 1) + abs(h[i] - h[i - 1]));
if (i > 1)
res = min(res, rec(i - 2) + abs(h[i] - h[i - 2]));
return dp[i] = res;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++)
cin >> h[i];
for (int i = 0; i < 100100; i++)
dp[i] = inf;
cout << rec(n - 1) << endl;
return 0;
} | [
"variable_declaration.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 954,398 | 954,399 | u195054737 | cpp |
p03160 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
// ****************************************CODE***************************************//
ll n;
ll h[100100];
ll dp[100100];
int main() {
cin >> n;
for (int i = 0; i < n; i++)
cin >> h[i];
for (int i = 0; i < 100100; i++)
dp[i] = inf;
dp[0] = 0;
for (int i = 0; i < n; i++) {
dp[i + 1] = min(dp[i + 1], dp[i] + abs(h[i] - h[i - 1]));
dp[i + 2] = min(dp[i + 2], dp[i] + abs(h[i] - h[i - 2]));
}
cout << dp[n - 1] << endl;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
// ****************************************CODE***************************************//
ll n;
ll h[100100];
ll dp[100100];
int main() {
cin >> n;
for (int i = 0; i < n; i++)
cin >> h[i];
for (int i = 0; i < 100100; i++)
dp[i] = inf;
dp[0] = 0;
for (int i = 0; i < n; i++) {
dp[i + 1] = min(dp[i + 1], dp[i] + abs(h[i] - h[i + 1]));
dp[i + 2] = min(dp[i + 2], dp[i] + abs(h[i] - h[i + 2]));
}
cout << dp[n - 1] << endl;
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 954,393 | 954,400 | u195054737 | cpp |
p03160 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define _upgrade \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define pb push_back
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
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;
}
// ****************************************CODE***************************************//
ll n;
ll h[100010];
ll dp[100010];
ll rec(int i) {
if (dp[i] != inf)
return dp[i];
if (i == 0)
return 0;
ll res = inf;
res = min(res, rec(n - 1) + abs(h[i] - h[i - 1]));
if (i > 1)
res = min(res, rec(n - 2) + abs(h[i] - h[i - 2]));
return dp[i] = res;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> h[i];
}
for (int i = 0; i < 100010; i++)
dp[i] = inf;
cout << rec(n - 1) << endl;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define _upgrade \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define pb push_back
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
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;
}
// ****************************************CODE***************************************//
ll n;
ll h[100010];
ll dp[100010];
ll rec(int i) {
if (dp[i] != inf)
return dp[i];
if (i == 0)
return 0;
ll res = inf;
res = min(res, rec(i - 1) + abs(h[i] - h[i - 1]));
if (i > 1)
res = min(res, rec(i - 2) + abs(h[i] - h[i - 2]));
return dp[i] = res;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> h[i];
}
for (int i = 0; i < 100010; i++)
dp[i] = inf;
cout << rec(n - 1) << endl;
} | [
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 954,401 | 954,402 | u195054737 | cpp |
p03160 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define _upgrade \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define pb push_back
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
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;
}
// ****************************************CODE***************************************//
ll n;
ll h[100010];
ll 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++) {
dp[i] = min(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
if (i > 1)
dp[i] = min(dp[i], dp[i - 1] + abs(h[i] - h[i - 2]));
}
cout << dp[n - 1] << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define _upgrade \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define pb push_back
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
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;
}
// ****************************************CODE***************************************//
ll n;
ll h[100010];
ll 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++) {
dp[i] = min(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
if (i > 1)
dp[i] = min(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
cout << dp[n - 1] << endl;
return 0;
} | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 954,403 | 954,404 | u195054737 | cpp |
p03160 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define _upgrade \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define pb push_back
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
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;
}
// ****************************************CODE***************************************//
ll n, k;
ll h[110000];
ll dp[110000];
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++)
cin >> h[i];
for (int i = 0; i < 110000; i++)
dp[i] = inf;
dp[0] = 0;
for (int i = 0; i < n; i++) {
dp[i + 1] = min(dp[i + 1], dp[i] + abs(h[i] - h[i + 1]));
dp[i + 2] = min(dp[i + 2], dp[i] + abs(h[i] - h[i + 2]));
}
cout << dp[n - 1] << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define _upgrade \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define pb push_back
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
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;
}
// ****************************************CODE***************************************//
ll n, k;
ll h[110000];
ll dp[110000];
int main() {
cin >> n;
for (int i = 0; i < n; i++)
cin >> h[i];
for (int i = 0; i < 110000; i++)
dp[i] = inf;
dp[0] = 0;
for (int i = 0; i < n; i++) {
dp[i + 1] = min(dp[i + 1], dp[i] + abs(h[i] - h[i + 1]));
dp[i + 2] = min(dp[i + 2], dp[i] + abs(h[i] - h[i + 2]));
}
cout << dp[n - 1] << endl;
return 0;
} | [
"expression.operation.binary.remove"
] | 954,405 | 954,406 | u195054737 | cpp |
p03160 | #include <algorithm>
#include <limits.h>
#include <stdio.h>
#define SIZE 100005
int dp[100005], h[100005];
int main(void) {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d", &h[i]);
dp[0] = INT_MAX;
for (int i = 2; i <= n; i++)
dp[i] = std::min(dp[i - 1] + std::abs(h[i] - h[i - 1]),
dp[i - 2] + std::abs(h[i] - h[i - 2]));
printf("%d", dp[n]);
return 0;
}
| #include <algorithm>
#include <limits.h>
#include <stdio.h>
#define SIZE 100005
long long int dp[100005], h[100005];
int main(void) {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%lld", &h[i]);
dp[0] = INT_MAX;
for (int i = 2; i <= n; i++)
dp[i] = std::min(dp[i - 1] + std::abs(h[i] - h[i - 1]),
dp[i - 2] + std::abs(h[i] - h[i - 2]));
printf("%lld", dp[n]);
return 0;
}
| [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 954,419 | 954,420 | u563168133 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int n;
long long a[100007];
long long mem[100007];
long long res = 0;
// long long swim(int i,int lst=a[0])
//{
// if(i == n)
// return a[i];
// if(i>n)
// return 1e10 ;
//// long long &r = mem[i];
//// if(~r)
//// return mem[i];
// res = min(swim(i+1,a[i]) + abs(lst-a[i+1]),swim(i+2,a[i]) +
// abs(lst-a[i+2]));
//// cout<<i<<" "<<abs(a[i]-swim(i+1,a[i]))<<"
///"<<abs(a[i]-swim(i+2,a[i]))<<endl;
// return res;
//}
int main() {
cin >> n;
memset(mem, -1, sizeof(mem));
for (int i = 0; i < n; ++i)
cin >> a[i];
// cout<<min(swim(1,a[0]),swim(2,a[0]))<<endl;
mem[0] = 0;
mem[1] = abs(a[0] - a[1]);
for (int i = 2; i < n; ++i) {
mem[i] = min(mem[i - 1] + abs(a[i] - a[i - 1]),
mem[i - 1] + abs(a[i] - a[i - 2]));
}
cout << mem[n - 1] << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int n;
long long a[100007];
long long mem[100007];
long long res = 0;
// long long swim(int i,int lst=a[0])
//{
// if(i == n)
// return a[i];
// if(i>n)
// return 1e10 ;
//// long long &r = mem[i];
//// if(~r)
//// return mem[i];
// res = min(swim(i+1,a[i]) + abs(lst-a[i+1]),swim(i+2,a[i]) +
// abs(lst-a[i+2]));
//// cout<<i<<" "<<abs(a[i]-swim(i+1,a[i]))<<"
///"<<abs(a[i]-swim(i+2,a[i]))<<endl;
// return res;
//}
int main() {
cin >> n;
memset(mem, -1, sizeof(mem));
for (int i = 0; i < n; ++i)
cin >> a[i];
// cout<<min(swim(1,a[0]),swim(2,a[0]))<<endl;
mem[0] = 0;
mem[1] = abs(a[0] - a[1]);
for (int i = 2; i < n; ++i) {
mem[i] = min(mem[i - 1] + abs(a[i] - a[i - 1]),
mem[i - 2] + abs(a[i] - a[i - 2]));
}
cout << mem[n - 1] << endl;
}
| [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 954,427 | 954,428 | u207553808 | cpp |
p03160 | #include <bits/stdc++.h>
#define ll long long
using namespace std;
ll a[100009], b, c, d, n, dp[100009];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
dp[0] = 0;
dp[1] = abs(a[0] - a[1]);
for (int i = 1; i < n; i++) {
b = abs(a[i] - a[i - 1]) + dp[i - 1];
c = abs(a[i] - a[i - 2]) + dp[i - 2];
dp[i] = min(b, c);
}
cout << dp[n - 1] << endl;
} | #include <bits/stdc++.h>
#define ll long long
using namespace std;
ll a[100009], b, c, d, n, dp[100009];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
dp[0] = 0;
dp[1] = abs(a[0] - a[1]);
for (int i = 2; i < n; i++) {
b = abs(a[i] - a[i - 1]) + dp[i - 1];
c = abs(a[i] - a[i - 2]) + dp[i - 2];
dp[i] = min(b, c);
}
cout << dp[n - 1] << endl;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 954,429 | 954,430 | u706943728 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int h[200000];
int dp[200000];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> h[i];
}
dp[0] = 0;
dp[1] = h[1] - h[0];
for (int i = 2; i < n; i++) {
dp[i] =
min(dp[i - 1] + abs(h[i - 1] - h[i]), dp[i - 2] + abs(h[i - 2] - h[i]));
}
cout << dp[n - 1] << "\n";
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int h[200000];
int dp[200000];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> h[i];
}
dp[0] = 0;
dp[1] = abs(h[1] - h[0]);
for (int i = 2; i < n; i++) {
dp[i] =
min(dp[i - 1] + abs(h[i - 1] - h[i]), dp[i - 2] + abs(h[i - 2] - h[i]));
}
cout << dp[n - 1] << "\n";
return 0;
} | [
"call.add",
"call.arguments.change"
] | 954,433 | 954,434 | u019361658 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
#define in insert
#define mk make_pair
#define pb push_back
#define pf push_front
#define pob pop_back
#define pof pop_front
#define all(a) a.begin(), a.end()
#define INF (1 << 28)
typedef long long int ll;
typedef long int l;
typedef pair<int, int> pii;
const double PI = acos(-1);
int dp[100005];
void initialize() {
for (int i = 0; i < 100005; i++)
dp[i] = 999999;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int arr[100005];
for (int i = 0; i < n; i++)
cin >> arr[i];
initialize();
dp[0] = 0;
for (int i = 0; i < n - 1; i++) {
if (i + 1 < n)
dp[i + 1] = min(dp[i + 1], dp[i] + abs(arr[i + 1] - arr[i]));
if (i + 2 < n)
dp[i + 2] = min(dp[i + 2], dp[i] + abs(arr[i + 2] - arr[i]));
}
// for(int i=0;i<n;i++){
// cout<<dp[i]<<endl;
// }
cout << dp[n - 1] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define in insert
#define mk make_pair
#define pb push_back
#define pf push_front
#define pob pop_back
#define pof pop_front
#define all(a) a.begin(), a.end()
#define INF (1 << 28)
typedef long long int ll;
typedef long int l;
typedef pair<int, int> pii;
const double PI = acos(-1);
ll dp[100005];
void initialize() {
for (int i = 0; i < 100005; i++)
dp[i] = 999999999999;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int arr[100005];
for (int i = 0; i < n; i++)
cin >> arr[i];
initialize();
dp[0] = 0;
for (int i = 0; i < n - 1; i++) {
if (i + 1 < n)
dp[i + 1] = min(dp[i + 1], dp[i] + abs(arr[i + 1] - arr[i]));
if (i + 2 < n)
dp[i + 2] = min(dp[i + 2], dp[i] + abs(arr[i + 2] - arr[i]));
}
// for(int i=0;i<n;i++){
// cout<<dp[i]<<endl;
// }
cout << dp[n - 1] << endl;
return 0;
} | [
"variable_declaration.type.change",
"literal.number.change",
"assignment.value.change"
] | 954,451 | 954,450 | u565802566 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
int solve() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int dp[n];
dp[0] = 0;
dp[1] = abs(a[1] - a[0]);
for (int i = 2; i < n; i++) {
dp[i] =
min(dp[i - 1] + abs(a[i] - a[i - 1]), dp[i - 2] + abs(a[i] - a[i - 2]));
}
// for(int i=0;i<n;i++)
// {
// cout<<dp[i]<<" ";
// }
return dp[n - 1];
}
int main() {
int t;
cin >> t;
while (t--) {
cout << solve();
}
}
| #include <bits/stdc++.h>
using namespace std;
int solve() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int dp[n];
dp[0] = 0;
dp[1] = abs(a[1] - a[0]);
for (int i = 2; i < n; i++) {
dp[i] =
min(dp[i - 1] + abs(a[i] - a[i - 1]), dp[i - 2] + abs(a[i] - a[i - 2]));
}
// for(int i=0;i<n;i++)
// {
// cout<<dp[i]<<" ";
// }
return dp[n - 1];
}
int main() {
int t;
t = 1;
while (t--) {
cout << solve();
}
}
| [
"expression.operation.binary.remove",
"assignment.change"
] | 954,468 | 954,469 | u727469412 | cpp |
p03160 | #include <cmath>
#include <iostream>
using namespace std;
long long int cost1(int N, int h[]) {
int cost[N] = {0};
cost[0] = 0;
cost[1] = abs(h[N - 2] - h[N - 1]);
for (int i = 2; i < N; i++) {
cost[i] = min(abs(h[i] - h[i - 1]) + cost[i - 1],
abs(h[i] - h[i - 2]) + cost[i - 2]);
}
// for(int i=0;i<N;i++)
// printf("%d ",cost[i]);
return cost[N - 1];
}
int main() {
int N;
cin >> N;
int h[N] = {0};
for (int i = 0; i < N; i++)
cin >> h[i];
printf("%lld\n", cost1(N, h));
return 0;
} | #include <cmath>
#include <iostream>
using namespace std;
long long int cost1(int N, int h[]) {
int cost[N] = {0};
cost[0] = 0;
cost[1] = abs(h[1] - h[0]);
for (int i = 2; i < N; i++) {
cost[i] = min(abs(h[i] - h[i - 1]) + cost[i - 1],
abs(h[i] - h[i - 2]) + cost[i - 2]);
}
// for(int i=0;i<N;i++)
// printf("%d ",cost[i]);
return cost[N - 1];
}
int main() {
int N;
cin >> N;
int h[N] = {0};
for (int i = 0; i < N; i++)
cin >> h[i];
printf("%lld\n", cost1(N, h));
return 0;
} | [
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 954,477 | 954,478 | u499215329 | cpp |
p03160 | #include <iostream>
using namespace std;
int main() {
int a1, a2;
int length;
cin >> length;
int height[length];
for (int i = 0; i < length; ++i) {
cin >> height[i];
}
a2 = 0;
if (height[1] > height[0])
a1 = height[0] - height[1];
else
a1 = height[1] - height[0];
int temp1, temp2;
for (int i = 2; i < length; ++i) {
if (height[i - 1] >= height[i])
temp1 = (height[i - 1] - height[i]) + a1;
else if (height[i] > height[i - 1])
temp1 = (height[i] - height[i - 1]) + a1;
if (height[i - 2] >= height[i])
temp2 = (height[i - 2] - height[i]) + a2;
else if (height[i] > height[i - 2])
temp2 = (height[i] - height[i - 2]) + a2;
if (temp2 >= temp1) {
a2 = a1;
a1 = temp1;
} else {
a2 = a1;
a1 = temp2;
}
}
cout << a1;
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int a1, a2;
int length;
cin >> length;
int height[length];
for (int i = 0; i < length; ++i) {
cin >> height[i];
}
a2 = 0;
if (height[1] > height[0])
a1 = height[1] - height[0];
else
a1 = height[0] - height[1];
int temp1, temp2;
for (int i = 2; i < length; ++i) {
if (height[i - 1] >= height[i])
temp1 = (height[i - 1] - height[i]) + a1;
else if (height[i] > height[i - 1])
temp1 = (height[i] - height[i - 1]) + a1;
if (height[i - 2] >= height[i])
temp2 = (height[i - 2] - height[i]) + a2;
else if (height[i] > height[i - 2])
temp2 = (height[i] - height[i - 2]) + a2;
if (temp2 >= temp1) {
a2 = a1;
a1 = temp1;
} else {
a2 = a1;
a1 = temp2;
}
}
cout << a1;
return 0;
}
| [
"control_flow.branch.else.remove",
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add",
"assignment.add"
] | 954,479 | 954,480 | u840752761 | cpp |
p03160 | #include <iostream>
using namespace std;
int main() {
int a1, a2;
int length;
cin >> length;
int height[length];
for (int i = 0; i < length; ++i) {
cin >> height[i];
}
a2 = 0;
if (height[1] > height[0])
a1 = height[0] - height[1];
else
a1 = height[0] - height[1];
int temp1, temp2;
for (int i = 2; i < length; ++i) {
if (height[i - 1] >= height[i])
temp1 = (height[i - 1] - height[i]) + a1;
else if (height[i] > height[i - 1])
temp1 = (height[i] - height[i - 1]) + a1;
if (height[i - 2] >= height[i])
temp2 = (height[i - 2] - height[i]) + a2;
else if (height[i] > height[i - 2])
temp2 = (height[i] - height[i - 2]) + a2;
if (temp2 >= temp1) {
a2 = a1;
a1 = temp1;
} else {
a2 = a1;
a1 = temp2;
}
}
cout << a1;
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int a1, a2;
int length;
cin >> length;
int height[length];
for (int i = 0; i < length; ++i) {
cin >> height[i];
}
a2 = 0;
if (height[1] > height[0])
a1 = height[1] - height[0];
else
a1 = height[0] - height[1];
int temp1, temp2;
for (int i = 2; i < length; ++i) {
if (height[i - 1] >= height[i])
temp1 = (height[i - 1] - height[i]) + a1;
else if (height[i] > height[i - 1])
temp1 = (height[i] - height[i - 1]) + a1;
if (height[i - 2] >= height[i])
temp2 = (height[i - 2] - height[i]) + a2;
else if (height[i] > height[i - 2])
temp2 = (height[i] - height[i - 2]) + a2;
if (temp2 >= temp1) {
a2 = a1;
a1 = temp1;
} else {
a2 = a1;
a1 = temp2;
}
}
cout << a1;
return 0;
}
| [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 954,481 | 954,480 | u840752761 | cpp |
p03160 | #include <iostream>
using namespace std;
int main() {
int a1, a2;
int length;
cin >> length;
int height[length];
for (int i = 0; i < length; ++i) {
cin >> height[i];
}
a2 = height[0];
if (height[1] > height[0])
a1 = height[0] - height[1];
else
a1 = height[0] - height[1];
int temp1, temp2;
for (int i = 2; i < length; ++i) {
if (height[i - 1] >= height[i])
temp1 = (height[i - 1] - height[i]) + a1;
else if (height[i] > height[i - 1])
temp1 = (height[i] - height[i - 1]) + a1;
if (height[i - 2] >= height[i])
temp2 = (height[i - 2] - height[i]) + a2;
else if (height[i] > height[i - 2])
temp2 = (height[i] - height[i - 2]) + a2;
if (temp2 >= temp1) {
a2 = a1;
a1 = temp1;
} else {
a2 = a1;
a1 = temp2;
}
}
cout << a1;
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int a1, a2;
int length;
cin >> length;
int height[length];
for (int i = 0; i < length; ++i) {
cin >> height[i];
}
a2 = 0;
if (height[1] > height[0])
a1 = height[1] - height[0];
else
a1 = height[0] - height[1];
int temp1, temp2;
for (int i = 2; i < length; ++i) {
if (height[i - 1] >= height[i])
temp1 = (height[i - 1] - height[i]) + a1;
else if (height[i] > height[i - 1])
temp1 = (height[i] - height[i - 1]) + a1;
if (height[i - 2] >= height[i])
temp2 = (height[i - 2] - height[i]) + a2;
else if (height[i] > height[i - 2])
temp2 = (height[i] - height[i - 2]) + a2;
if (temp2 >= temp1) {
a2 = a1;
a1 = temp1;
} else {
a2 = a1;
a1 = temp2;
}
}
cout << a1;
return 0;
}
| [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 954,482 | 954,480 | u840752761 | cpp |
p03152 | #include <bits/stdc++.h>
using namespace std;
typedef signed long long ll;
#undef _P
#define _P(...) (void)printf(__VA_ARGS__)
#define FOR(x, to) for (x = 0; x < (to); x++)
#define FORR(x, arr) for (auto &x : arr)
#define ITR(x, c) for (__typeof(c.begin()) x = c.begin(); x != c.end(); x++)
#define ALL(a) (a.begin()), (a.end())
#define ZERO(a) memset(a, 0, sizeof(a))
#define MINUS(a) memset(a, 0xff, sizeof(a))
//-------------------------------------------------------
int H, W;
int A[1010], B[1010];
int As[1010 * 1010];
int Bs[1010 * 1010];
int C[1010][1010];
ll mo = 1000000007;
void solve() {
int i, j, k, l, r, x, y;
string s;
MINUS(As);
MINUS(Bs);
cin >> H >> W;
FOR(i, H) {
cin >> A[i];
if (As[A[i]] >= 0)
return _P("-1\n");
As[A[i]] = i;
}
FOR(i, W) {
cin >> B[i];
if (Bs[B[i]] >= 0)
return _P("-1\n");
Bs[B[i]] = i;
}
ll ret = 1;
int cand = 0;
for (i = H * W; i >= 1; i--) {
if (As[i] >= 0 && Bs[i] >= 0) {
FOR(x, W) {
if (C[As[i]][x] == 1)
cand++;
C[As[i]][x]++;
}
FOR(y, H) {
if (C[y][Bs[i]] == 1)
cand++;
C[y][Bs[i]]++;
}
} else if (As[i] >= 0) {
int pat = 0;
FOR(x, W) {
if (C[As[i]][x] == 1)
cand++;
C[As[i]][x]++;
if (C[As[i]][x] == 2)
pat++;
}
ret = ret * pat % mo;
} else if (Bs[i] >= 0) {
int pat = 0;
FOR(y, H) {
if (C[y][Bs[i]] == 1)
cand++;
C[y][Bs[i]]++;
if (C[y][Bs[i]] == 2)
pat++;
}
ret = ret * pat % mo;
} else {
ret = ret * cand % mo;
}
cand--;
}
cout << ret << endl;
}
int main(int argc, char **argv) {
string s;
int i;
if (argc == 1)
ios::sync_with_stdio(false), cin.tie(0);
FOR(i, argc - 1) s += argv[i + 1], s += '\n';
FOR(i, s.size()) ungetc(s[s.size() - 1 - i], stdin);
cout.tie(0);
solve();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef signed long long ll;
#undef _P
#define _P(...) (void)printf(__VA_ARGS__)
#define FOR(x, to) for (x = 0; x < (to); x++)
#define FORR(x, arr) for (auto &x : arr)
#define ITR(x, c) for (__typeof(c.begin()) x = c.begin(); x != c.end(); x++)
#define ALL(a) (a.begin()), (a.end())
#define ZERO(a) memset(a, 0, sizeof(a))
#define MINUS(a) memset(a, 0xff, sizeof(a))
//-------------------------------------------------------
int H, W;
int A[1010], B[1010];
int As[1010 * 1010];
int Bs[1010 * 1010];
int C[1010][1010];
ll mo = 1000000007;
void solve() {
int i, j, k, l, r, x, y;
string s;
MINUS(As);
MINUS(Bs);
cin >> H >> W;
FOR(i, H) {
cin >> A[i];
if (As[A[i]] >= 0)
return _P("0\n");
As[A[i]] = i;
}
FOR(i, W) {
cin >> B[i];
if (Bs[B[i]] >= 0)
return _P("0\n");
Bs[B[i]] = i;
}
ll ret = 1;
int cand = 0;
for (i = H * W; i >= 1; i--) {
if (As[i] >= 0 && Bs[i] >= 0) {
FOR(x, W) {
if (C[As[i]][x] == 1)
cand++;
C[As[i]][x]++;
}
FOR(y, H) {
if (C[y][Bs[i]] == 1)
cand++;
C[y][Bs[i]]++;
}
} else if (As[i] >= 0) {
int pat = 0;
FOR(x, W) {
if (C[As[i]][x] == 1)
cand++;
C[As[i]][x]++;
if (C[As[i]][x] == 2)
pat++;
}
ret = ret * pat % mo;
} else if (Bs[i] >= 0) {
int pat = 0;
FOR(y, H) {
if (C[y][Bs[i]] == 1)
cand++;
C[y][Bs[i]]++;
if (C[y][Bs[i]] == 2)
pat++;
}
ret = ret * pat % mo;
} else {
ret = ret * cand % mo;
}
cand--;
}
cout << ret << endl;
}
int main(int argc, char **argv) {
string s;
int i;
if (argc == 1)
ios::sync_with_stdio(false), cin.tie(0);
FOR(i, argc - 1) s += argv[i + 1], s += '\n';
FOR(i, s.size()) ungetc(s[s.size() - 1 - i], stdin);
cout.tie(0);
solve();
return 0;
}
| [
"literal.string.change",
"call.arguments.change",
"function.return_value.change"
] | 954,505 | 954,506 | u452725238 | cpp |
p03153 | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define ll long long
#define ull unsigned long long
#define db double
#define pb push_back
#define ppb pop_back
#define all(x) (x).begin(), (x).end()
template <typename T> using pr = array<T, 3>;
template <typename T>
using ord_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int N = 200003;
int n, sz[N], par[N];
ll d, a[N];
vector<pr<ll>> cand;
void rec(int l, int r) {
if (l >= r) {
return;
}
int m = l + r >> 1;
int L = -1, R = -1;
for (int i = l; i <= m; i++) {
if (L == -1 || a[i] - i * d < a[L] - L * d) {
L = i;
}
}
for (int i = m + 1; i <= r; i++) {
cand.pb({a[L] + a[i] + (i - L) * d, L, i});
if (R == -1 || a[i] + i * d < a[R] - R * d) {
R = i;
}
}
for (int i = l; i <= m; i++) {
cand.pb({a[R] + a[i] + (R - i) * d, i, R});
}
rec(l, m);
rec(m + 1, r);
}
void make_set(int x) {
par[x] = x;
sz[x] = 1;
}
int find_set(int x) {
if (x == par[x]) {
return x;
}
return par[x] = find_set(par[x]);
}
bool union_set(int x, int y) {
x = find_set(x), y = find_set(y);
if (x == y) {
return false;
}
if (sz[x] < sz[y]) {
swap(x, y);
}
par[y] = x;
sz[x] += sz[y];
return true;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
#ifdef LOCAL
freopen("input.txt", "r", stdin);
#endif
cin >> n >> d;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
rec(1, n);
sort(all(cand));
ll ans = 0;
for (int i = 1; i <= n; i++) {
make_set(i);
}
for (auto i : cand) {
int w = i[0], x = i[1], y = i[2];
if (union_set(x, y)) {
ans += w;
}
}
cout << ans;
}
| #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define ll long long
#define ull unsigned long long
#define db double
#define pb push_back
#define ppb pop_back
#define all(x) (x).begin(), (x).end()
template <typename T> using pr = array<T, 3>;
template <typename T>
using ord_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int N = 200003;
int n, sz[N], par[N];
ll d, a[N];
vector<pr<ll>> cand;
void rec(int l, int r) {
if (l >= r) {
return;
}
int m = l + r >> 1;
int L = -1, R = -1;
for (int i = l; i <= m; i++) {
if (L == -1 || a[i] - i * d < a[L] - L * d) {
L = i;
}
}
for (int i = m + 1; i <= r; i++) {
cand.pb({a[L] + a[i] + (i - L) * d, L, i});
if (R == -1 || a[i] + i * d < a[R] + R * d) {
R = i;
}
}
for (int i = l; i <= m; i++) {
cand.pb({a[R] + a[i] + (R - i) * d, i, R});
}
rec(l, m);
rec(m + 1, r);
}
void make_set(int x) {
par[x] = x;
sz[x] = 1;
}
int find_set(int x) {
if (x == par[x]) {
return x;
}
return par[x] = find_set(par[x]);
}
bool union_set(int x, int y) {
x = find_set(x), y = find_set(y);
if (x == y) {
return false;
}
if (sz[x] < sz[y]) {
swap(x, y);
}
par[y] = x;
sz[x] += sz[y];
return true;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
#ifdef LOCAL
freopen("input.txt", "r", stdin);
#endif
cin >> n >> d;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
rec(1, n);
sort(all(cand));
ll ans = 0;
for (int i = 1; i <= n; i++) {
make_set(i);
}
for (auto i : cand) {
ll w = i[0];
int x = i[1], y = i[2];
if (union_set(x, y)) {
ans += w;
}
}
cout << ans;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change",
"variable_declaration.type.change"
] | 954,513 | 954,512 | u322084037 | cpp |
p03153 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, int> pli;
#define fir first
#define sec second
#define Mp make_pair
const int MAXN = 2e5 + 5;
const int inf = 0x3f3f3f3f;
const ll linf = 0x3f3f3f3f3f3f3f3f;
template <typename T> void chk_min(T &a, T b) {
if (a > b)
a = b;
}
ll a[MAXN];
int main(void) {
int n;
ll d;
scanf("%d%lld", &n, &d);
for (int i = 1; i <= n; ++i)
scanf("%lld", &a[i]);
ll ans = 0;
for (int i = 1; i <= n; ++i)
ans += a[i];
for (int i = 1; i <= n; ++i)
chk_min(a[i], a[i - 1] + d);
for (int i = n - 1; i >= 1; --i)
chk_min(a[i], a[i + 1] + d);
for (int i = 1; i <= n; ++i)
ans += a[i];
printf("%lld", ans + d * (n - 1) - a[1] - a[n]);
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, int> pli;
#define fir first
#define sec second
#define Mp make_pair
const int MAXN = 2e5 + 5;
const int inf = 0x3f3f3f3f;
const ll linf = 0x3f3f3f3f3f3f3f3f;
template <typename T> void chk_min(T &a, T b) {
if (a > b)
a = b;
}
ll a[MAXN];
int main(void) {
int n;
ll d;
scanf("%d%lld", &n, &d);
for (int i = 1; i <= n; ++i)
scanf("%lld", &a[i]);
ll ans = 0;
for (int i = 1; i <= n; ++i)
ans += a[i];
for (int i = 2; i <= n; ++i)
chk_min(a[i], a[i - 1] + d);
for (int i = n - 1; i >= 1; --i)
chk_min(a[i], a[i + 1] + d);
for (int i = 1; i <= n; ++i)
ans += a[i];
printf("%lld", ans + d * (n - 1) - a[1] - a[n]);
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 954,518 | 954,519 | u042689916 | cpp |
p03153 | /*----------------by syr----------------*/
/*
----- ----- -----
| | |---| _/
| | | \_ /
----- | \ -----
|---\ \ / |\ /|
| | \_/ | \/ |
| | / \ | |
|---/ / \ | |
*/
#include <bits/stdc++.h>
using namespace std;
#define PH push
#define MP make_pair
#define PB push_back
#define fst first
#define snd second
#define FOR(i, x, y) for (int i = (x); i < (y); ++i)
#define REP(i, x, y) for (int i = (x); i <= (y); ++i)
#define x0 x0123456789
#define y0 y0123456789
#define x1 x1234567890
#define y1 y1234567890
#define x2 x2345678901
#define y2 y2345678901
typedef double db;
typedef long long ll;
typedef long double ldb;
typedef pair<int, int> pii;
const int INF = 1e9 + 7;
const int maxn = 2e5 + 5;
struct Edge {
ll w;
int u;
int v;
Edge(ll w, int u, int v) : w(w), u(u), v(v) {}
inline bool operator<(const Edge &b) const { return w < b.w; }
};
class Dsu {
private:
int sz;
int fa[maxn];
public:
inline void init(int n) {
sz = n;
FOR(i, 0, sz) fa[i] = i;
return;
}
inline int find(int x) { return (x == fa[x]) ? (x) : (fa[x] = find(fa[x])); }
inline void combine(int x, int y) {
x = find(x);
y = find(y);
fa[x] = y;
return;
}
} dsu;
int n;
int a[maxn];
ll d, ans;
vector<Edge> vec;
inline void solve(int l, int r) {
if (l >= r)
return;
int md = (l + r) >> 1;
solve(l, md);
solve(md + 1, r);
int va = r, vs = l;
REP(i, l + 1, md) if (a[i] - d * i <= a[vs] - d * i) vs = i;
FOR(i, md + 1, r) if (a[i] + d * i <= a[va] + d * i) va = i;
REP(i, l, md) vec.PB(Edge((va - i) * d + a[va] + a[i], va, i));
REP(i, md + 1, r) vec.PB(Edge((i - vs) * d + a[vs] + a[i], vs, i));
return;
}
int main() {
scanf("%d%lld", &n, &d);
FOR(i, 0, n) scanf("%d", a + i);
solve(0, n - 1);
sort(vec.begin(), vec.end());
dsu.init(n);
FOR(i, 0, vec.size()) {
int u = vec[i].u, v = vec[i].v;
if (dsu.find(u) == dsu.find(v))
continue;
// printf("u=%d v=%d\n",u,v);
ans += vec[i].w;
dsu.combine(u, v);
}
printf("%lld\n", ans);
return 0;
}
| /*----------------by syr----------------*/
/*
----- ----- -----
| | |---| _/
| | | \_ /
----- | \ -----
|---\ \ / |\ /|
| | \_/ | \/ |
| | / \ | |
|---/ / \ | |
*/
#include <bits/stdc++.h>
using namespace std;
#define PH push
#define MP make_pair
#define PB push_back
#define fst first
#define snd second
#define FOR(i, x, y) for (int i = (x); i < (y); ++i)
#define REP(i, x, y) for (int i = (x); i <= (y); ++i)
#define x0 x0123456789
#define y0 y0123456789
#define x1 x1234567890
#define y1 y1234567890
#define x2 x2345678901
#define y2 y2345678901
typedef double db;
typedef long long ll;
typedef long double ldb;
typedef pair<int, int> pii;
const int INF = 1e9 + 7;
const int maxn = 2e5 + 5;
struct Edge {
ll w;
int u;
int v;
Edge(ll w, int u, int v) : w(w), u(u), v(v) {}
inline bool operator<(const Edge &b) const { return w < b.w; }
};
class Dsu {
private:
int sz;
int fa[maxn];
public:
inline void init(int n) {
sz = n;
FOR(i, 0, sz) fa[i] = i;
return;
}
inline int find(int x) { return (x == fa[x]) ? (x) : (fa[x] = find(fa[x])); }
inline void combine(int x, int y) {
x = find(x);
y = find(y);
fa[x] = y;
return;
}
} dsu;
int n;
int a[maxn];
ll d, ans;
vector<Edge> vec;
inline void solve(int l, int r) {
if (l == r)
return;
int md = (l + r) >> 1;
solve(l, md);
solve(md + 1, r);
int va = r, vs = l;
REP(i, l + 1, md) if (a[i] - d * i <= a[vs] - d * vs) vs = i;
FOR(i, md + 1, r) if (a[i] + d * i <= a[va] + d * va) va = i;
REP(i, l, md) vec.PB(Edge((va - i) * d + a[va] + a[i], va, i));
REP(i, md + 1, r) vec.PB(Edge((i - vs) * d + a[vs] + a[i], vs, i));
return;
}
int main() {
scanf("%d%lld", &n, &d);
FOR(i, 0, n) scanf("%d", a + i);
solve(0, n - 1);
sort(vec.begin(), vec.end());
dsu.init(n);
FOR(i, 0, vec.size()) {
int u = vec[i].u, v = vec[i].v;
if (dsu.find(u) == dsu.find(v))
continue;
// printf("u=%d v=%d\n",u,v);
ans += vec[i].w;
dsu.combine(u, v);
}
printf("%lld\n", ans);
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"identifier.change"
] | 954,528 | 954,529 | u904221771 | cpp |
p03153 | /*----------------by syr----------------*/
/*
----- ----- -----
| | |---| _/
| | | \_ /
----- | \ -----
|---\ \ / |\ /|
| | \_/ | \/ |
| | / \ | |
|---/ / \ | |
*/
#include <bits/stdc++.h>
using namespace std;
#define PH push
#define MP make_pair
#define PB push_back
#define fst first
#define snd second
#define FOR(i, x, y) for (int i = (x); i < (y); ++i)
#define REP(i, x, y) for (int i = (x); i <= (y); ++i)
#define x0 x0123456789
#define y0 y0123456789
#define x1 x1234567890
#define y1 y1234567890
#define x2 x2345678901
#define y2 y2345678901
typedef double db;
typedef long long ll;
typedef long double ldb;
typedef pair<int, int> pii;
const int INF = 1e9 + 7;
const int maxn = 1e5 + 5;
struct Edge {
ll w;
int u;
int v;
Edge(ll w, int u, int v) : w(w), u(u), v(v) {}
inline bool operator<(const Edge &b) const { return w < b.w; }
};
class Dsu {
private:
int sz;
int fa[maxn];
public:
inline void init(int n) {
sz = n;
FOR(i, 0, sz) fa[i] = i;
return;
}
inline int find(int x) { return (x == fa[x]) ? (x) : (fa[x] = find(fa[x])); }
inline void combine(int x, int y) {
x = find(x);
y = find(y);
fa[x] = y;
return;
}
} dsu;
int n;
int a[maxn];
ll d, ans;
vector<Edge> vec;
inline void solve(int l, int r) {
if (l >= r)
return;
int md = (l + r) >> 1;
solve(l, md);
solve(md + 1, r);
int va = r, vs = l;
REP(i, l + 1, md) if (a[i] - d * i <= a[vs] - d * i) vs = i;
FOR(i, md + 1, r) if (a[i] + d * i <= a[va] + d * i) va = i;
REP(i, l, md) vec.PB(Edge((va - i) * d + a[va] + a[i], va, i));
REP(i, md + 1, r) vec.PB(Edge((i - vs) * d + a[vs] + a[i], vs, i));
return;
}
int main() {
scanf("%d%lld", &n, &d);
FOR(i, 0, n) scanf("%d", a + i);
solve(0, n - 1);
sort(vec.begin(), vec.end());
dsu.init(n);
FOR(i, 0, vec.size()) {
int u = vec[i].u, v = vec[i].v;
if (dsu.find(u) == dsu.find(v))
continue;
// printf("u=%d v=%d\n",u,v);
ans += vec[i].w;
dsu.combine(u, v);
}
printf("%lld\n", ans);
return 0;
}
| /*----------------by syr----------------*/
/*
----- ----- -----
| | |---| _/
| | | \_ /
----- | \ -----
|---\ \ / |\ /|
| | \_/ | \/ |
| | / \ | |
|---/ / \ | |
*/
#include <bits/stdc++.h>
using namespace std;
#define PH push
#define MP make_pair
#define PB push_back
#define fst first
#define snd second
#define FOR(i, x, y) for (int i = (x); i < (y); ++i)
#define REP(i, x, y) for (int i = (x); i <= (y); ++i)
#define x0 x0123456789
#define y0 y0123456789
#define x1 x1234567890
#define y1 y1234567890
#define x2 x2345678901
#define y2 y2345678901
typedef double db;
typedef long long ll;
typedef long double ldb;
typedef pair<int, int> pii;
const int INF = 1e9 + 7;
const int maxn = 2e5 + 5;
struct Edge {
ll w;
int u;
int v;
Edge(ll w, int u, int v) : w(w), u(u), v(v) {}
inline bool operator<(const Edge &b) const { return w < b.w; }
};
class Dsu {
private:
int sz;
int fa[maxn];
public:
inline void init(int n) {
sz = n;
FOR(i, 0, sz) fa[i] = i;
return;
}
inline int find(int x) { return (x == fa[x]) ? (x) : (fa[x] = find(fa[x])); }
inline void combine(int x, int y) {
x = find(x);
y = find(y);
fa[x] = y;
return;
}
} dsu;
int n;
int a[maxn];
ll d, ans;
vector<Edge> vec;
inline void solve(int l, int r) {
if (l == r)
return;
int md = (l + r) >> 1;
solve(l, md);
solve(md + 1, r);
int va = r, vs = l;
REP(i, l + 1, md) if (a[i] - d * i <= a[vs] - d * vs) vs = i;
FOR(i, md + 1, r) if (a[i] + d * i <= a[va] + d * va) va = i;
REP(i, l, md) vec.PB(Edge((va - i) * d + a[va] + a[i], va, i));
REP(i, md + 1, r) vec.PB(Edge((i - vs) * d + a[vs] + a[i], vs, i));
return;
}
int main() {
scanf("%d%lld", &n, &d);
FOR(i, 0, n) scanf("%d", a + i);
solve(0, n - 1);
sort(vec.begin(), vec.end());
dsu.init(n);
FOR(i, 0, vec.size()) {
int u = vec[i].u, v = vec[i].v;
if (dsu.find(u) == dsu.find(v))
continue;
// printf("u=%d v=%d\n",u,v);
ans += vec[i].w;
dsu.combine(u, v);
}
printf("%lld\n", ans);
return 0;
}
| [
"literal.number.change",
"expression.operation.binary.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"identifier.change"
] | 954,530 | 954,529 | u904221771 | cpp |
p03153 | /*----------------by syr----------------*/
/*
----- ----- -----
| | |---| _/
| | | \_ /
----- | \ -----
|---\ \ / |\ /|
| | \_/ | \/ |
| | / \ | |
|---/ / \ | |
*/
#include <bits/stdc++.h>
using namespace std;
#define PH push
#define MP make_pair
#define PB push_back
#define fst first
#define snd second
#define FOR(i, x, y) for (int i = (x); i < (y); ++i)
#define REP(i, x, y) for (int i = (x); i <= (y); ++i)
#define x0 x0123456789
#define y0 y0123456789
#define x1 x1234567890
#define y1 y1234567890
#define x2 x2345678901
#define y2 y2345678901
typedef double db;
typedef long long ll;
typedef long double ldb;
typedef pair<int, int> pii;
const int INF = 1e9 + 7;
const int maxn = 1e5 + 5;
struct Edge {
ll w;
int u;
int v;
Edge(ll w, int u, int v) : w(w), u(u), v(v) {}
inline bool operator<(const Edge &b) const { return w < b.w; }
};
class Dsu {
private:
int sz;
int fa[maxn];
public:
inline void init(int n) {
sz = n;
FOR(i, 0, sz) fa[i] = i;
return;
}
inline int find(int x) { return (x == fa[x]) ? (x) : (fa[x] = find(fa[x])); }
inline void combine(int x, int y) {
x = find(x);
y = find(y);
fa[x] = y;
return;
}
} dsu;
int n;
int a[maxn];
ll d, ans;
vector<Edge> vec;
inline void solve(int l, int r) {
if (l == r)
return;
int md = (l + r) >> 1;
solve(l, md);
solve(md + 1, r);
int va = r, vs = l;
REP(i, l + 1, md) if (a[i] - d * i <= a[vs] - d * i) vs = i;
FOR(i, md + 1, r) if (a[i] + d * i <= a[va] + d * i) va = i;
REP(i, l, md) vec.PB(Edge((va - i) * d + a[va] + a[i], va, i));
REP(i, md + 1, r) vec.PB(Edge((i - vs) * d + a[vs] + a[i], vs, i));
return;
}
int main() {
scanf("%d%lld", &n, &d);
FOR(i, 0, n) scanf("%d", a + i);
solve(0, n - 1);
sort(vec.begin(), vec.end());
dsu.init(n);
FOR(i, 0, vec.size()) {
int u = vec[i].u, v = vec[i].v;
if (dsu.find(u) == dsu.find(v))
continue;
// printf("u=%d v=%d\n",u,v);
ans += vec[i].w;
dsu.combine(u, v);
}
printf("%lld\n", ans);
return 0;
}
| /*----------------by syr----------------*/
/*
----- ----- -----
| | |---| _/
| | | \_ /
----- | \ -----
|---\ \ / |\ /|
| | \_/ | \/ |
| | / \ | |
|---/ / \ | |
*/
#include <bits/stdc++.h>
using namespace std;
#define PH push
#define MP make_pair
#define PB push_back
#define fst first
#define snd second
#define FOR(i, x, y) for (int i = (x); i < (y); ++i)
#define REP(i, x, y) for (int i = (x); i <= (y); ++i)
#define x0 x0123456789
#define y0 y0123456789
#define x1 x1234567890
#define y1 y1234567890
#define x2 x2345678901
#define y2 y2345678901
typedef double db;
typedef long long ll;
typedef long double ldb;
typedef pair<int, int> pii;
const int INF = 1e9 + 7;
const int maxn = 2e5 + 5;
struct Edge {
ll w;
int u;
int v;
Edge(ll w, int u, int v) : w(w), u(u), v(v) {}
inline bool operator<(const Edge &b) const { return w < b.w; }
};
class Dsu {
private:
int sz;
int fa[maxn];
public:
inline void init(int n) {
sz = n;
FOR(i, 0, sz) fa[i] = i;
return;
}
inline int find(int x) { return (x == fa[x]) ? (x) : (fa[x] = find(fa[x])); }
inline void combine(int x, int y) {
x = find(x);
y = find(y);
fa[x] = y;
return;
}
} dsu;
int n;
int a[maxn];
ll d, ans;
vector<Edge> vec;
inline void solve(int l, int r) {
if (l == r)
return;
int md = (l + r) >> 1;
solve(l, md);
solve(md + 1, r);
int va = r, vs = l;
REP(i, l + 1, md) if (a[i] - d * i <= a[vs] - d * vs) vs = i;
FOR(i, md + 1, r) if (a[i] + d * i <= a[va] + d * va) va = i;
REP(i, l, md) vec.PB(Edge((va - i) * d + a[va] + a[i], va, i));
REP(i, md + 1, r) vec.PB(Edge((i - vs) * d + a[vs] + a[i], vs, i));
return;
}
int main() {
scanf("%d%lld", &n, &d);
FOR(i, 0, n) scanf("%d", a + i);
solve(0, n - 1);
sort(vec.begin(), vec.end());
dsu.init(n);
FOR(i, 0, vec.size()) {
int u = vec[i].u, v = vec[i].v;
if (dsu.find(u) == dsu.find(v))
continue;
// printf("u=%d v=%d\n",u,v);
ans += vec[i].w;
dsu.combine(u, v);
}
printf("%lld\n", ans);
return 0;
}
| [
"literal.number.change",
"expression.operation.binary.change",
"identifier.change",
"control_flow.branch.if.condition.change"
] | 954,531 | 954,529 | u904221771 | cpp |
p03153 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define ll long long
#define mp make_pair
#define pb push_back
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
const int maxn = 200005;
int n, d;
int a[maxn];
vector<pair<ll, pair<int, int>>> edges;
struct union_find {
int fa[maxn], siz[maxn];
union_find() {
for (int i = 0; i < maxn; ++i)
fa[i] = i, siz[i] = 1;
}
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
void merge(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (siz[x] < siz[y])
swap(x, y);
fa[y] = x;
siz[x] += siz[y];
}
} dsu;
void solve(int l, int r) {
if (l + 1 == r)
return;
int m = (l + r) >> 1;
vector<pair<ll, int>> lft, rgt;
for (int i = l; i < m; ++i)
lft.pb(mp(a[i] + 1LL * (m - i) * d, i));
for (int i = m; i < r; ++i)
rgt.pb(mp(a[i] + 1LL * (i - m) * d, i));
sort(lft.begin(), lft.end());
sort(rgt.begin(), rgt.end());
for (int i = 0; i < lft.size(); ++i)
edges.pb(mp(lft[i].first + rgt[0].first, mp(lft[i].second, rgt[i].second)));
for (int i = 0; i < rgt.size(); ++i)
edges.pb(mp(lft[0].first + rgt[i].first, mp(lft[0].second, rgt[i].second)));
solve(l, m);
solve(m, r);
}
int main() {
scanf("%d %d", &n, &d);
for (int i = 0; i < n; ++i)
scanf("%d", &a[i]);
solve(0, n);
sort(edges.begin(), edges.end());
ll ans = 0;
for (int i = 0; i < edges.size(); ++i) {
ll d = edges[i].first;
int u = edges[i].second.first;
int v = edges[i].second.second;
if (dsu.find(u) != dsu.find(v)) {
ans += d;
dsu.merge(u, v);
}
}
printf("%lld\n", ans);
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define ll long long
#define mp make_pair
#define pb push_back
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
const int maxn = 200005;
int n, d;
int a[maxn];
vector<pair<ll, pair<int, int>>> edges;
struct union_find {
int fa[maxn], siz[maxn];
union_find() {
for (int i = 0; i < maxn; ++i)
fa[i] = i, siz[i] = 1;
}
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
void merge(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (siz[x] < siz[y])
swap(x, y);
fa[y] = x;
siz[x] += siz[y];
}
} dsu;
void solve(int l, int r) {
if (l + 1 == r)
return;
int m = (l + r) >> 1;
vector<pair<ll, int>> lft, rgt;
for (int i = l; i < m; ++i)
lft.pb(mp(a[i] + 1LL * (m - i) * d, i));
for (int i = m; i < r; ++i)
rgt.pb(mp(a[i] + 1LL * (i - m) * d, i));
sort(lft.begin(), lft.end());
sort(rgt.begin(), rgt.end());
for (int i = 0; i < lft.size(); ++i)
edges.pb(mp(lft[i].first + rgt[0].first, mp(lft[i].second, rgt[0].second)));
for (int i = 0; i < rgt.size(); ++i)
edges.pb(mp(lft[0].first + rgt[i].first, mp(lft[0].second, rgt[i].second)));
solve(l, m);
solve(m, r);
}
int main() {
scanf("%d %d", &n, &d);
for (int i = 0; i < n; ++i)
scanf("%d", &a[i]);
solve(0, n);
sort(edges.begin(), edges.end());
ll ans = 0;
for (int i = 0; i < edges.size(); ++i) {
ll d = edges[i].first;
int u = edges[i].second.first;
int v = edges[i].second.second;
if (dsu.find(u) != dsu.find(v)) {
ans += d;
dsu.merge(u, v);
}
}
printf("%lld\n", ans);
return 0;
}
| [
"identifier.replace.remove",
"literal.replace.add",
"variable_access.subscript.index.change",
"call.arguments.change"
] | 954,539 | 954,540 | u274463010 | cpp |
p03153 | #include <bits/stdc++.h>
using namespace std;
using Int = long long;
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
template <typename T> struct Kruskal {
struct edge {
Int from, to;
T cost;
Int used;
edge() {}
edge(Int from, Int to, T cost) : from(from), to(to), cost(cost), used(0) {}
bool operator<(const edge &e) const { return cost < e.cost; }
};
Int n;
vector<Int> p, r;
vector<edge> edges;
Kruskal() {}
Kruskal(Int n) : n(n) {}
void init(Int n) {
r.assign(n, 1);
p.resize(n);
iota(p.begin(), p.end(), 0);
}
Int find(Int x) { return (x == p[x] ? x : p[x] = find(p[x])); }
bool same(Int x, Int y) { return find(x) == find(y); }
void unite(Int x, Int y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (r[x] < r[y])
swap(x, y);
r[x] += r[y];
p[y] = x;
}
void add_edge(Int u, Int v, T c) { edges.emplace_back(u, v, c); }
T build() {
sort(edges.begin(), edges.end());
init(n);
T res = 0;
for (auto &e : edges) {
if (!same(e.from, e.to)) {
res += e.cost;
unite(e.from, e.to);
e.used = 1;
}
}
return res;
}
};
struct FastIO {
FastIO() {
cin.tie(0);
ios::sync_with_stdio(0);
}
} fastio_beet;
// INSERT ABOVE HERE
signed main() {
Int n, d;
cin >> n >> d;
vector<Int> a(n);
for (Int i = 0; i < n; i++)
cin >> a[i];
Kruskal<Int> ks(n);
using P = pair<Int, Int>;
const Int INF = 1e18;
vector<P> ls(n, P(INF, -1)), rs(n, P(INF, -1)), dp(n);
function<void(Int, Int)> dfs = [&](Int l, Int r) -> void {
if (l + 1 == r) {
dp[l] = P(a[l], l);
return;
}
Int m = (l + r) >> 1;
dfs(l, m);
dfs(m, r);
P x(INF, -1), y(INF, -1);
for (Int i = l, j = m; i < m || j < r;) {
if (j == r || dp[i].first <= dp[j].first) {
Int k = dp[i++].second;
chmin(rs[k], y);
chmin(x, P(a[k] - k * d, k));
} else {
Int k = dp[j++].second;
chmin(ls[k], x);
chmin(y, P(a[k] + k * d, k));
}
}
inplace_merge(dp.begin() + l, dp.begin() + m, dp.begin() + r);
};
dfs(0, n);
auto add_edge = [&](Int x, Int y) {
if (x < 0 || y < 0)
return;
Int c = abs(x - y) * d + a[x] + a[y];
ks.add_edge(x, y, c);
};
for (Int i = 0; i < n; i++)
add_edge(ls[i].second, i);
for (Int i = 0; i < n; i++)
add_edge(i, rs[i].second);
cout << ks.build() << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using Int = long long;
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
template <typename T> struct Kruskal {
struct edge {
Int from, to;
T cost;
Int used;
edge() {}
edge(Int from, Int to, T cost) : from(from), to(to), cost(cost), used(0) {}
bool operator<(const edge &e) const { return cost < e.cost; }
};
Int n;
vector<Int> p, r;
vector<edge> edges;
Kruskal() {}
Kruskal(Int n) : n(n) {}
void init(Int n) {
r.assign(n, 1);
p.resize(n);
iota(p.begin(), p.end(), 0);
}
Int find(Int x) { return (x == p[x] ? x : p[x] = find(p[x])); }
bool same(Int x, Int y) { return find(x) == find(y); }
void unite(Int x, Int y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (r[x] < r[y])
swap(x, y);
r[x] += r[y];
p[y] = x;
}
void add_edge(Int u, Int v, T c) { edges.emplace_back(u, v, c); }
T build() {
sort(edges.begin(), edges.end());
init(n);
T res = 0;
for (auto &e : edges) {
if (!same(e.from, e.to)) {
res += e.cost;
unite(e.from, e.to);
e.used = 1;
}
}
return res;
}
};
struct FastIO {
FastIO() {
cin.tie(0);
ios::sync_with_stdio(0);
}
} fastio_beet;
// INSERT ABOVE HERE
signed main() {
Int n, d;
cin >> n >> d;
vector<Int> a(n);
for (Int i = 0; i < n; i++)
cin >> a[i];
Kruskal<Int> ks(n);
using P = pair<Int, Int>;
const Int INF = 1e18;
vector<P> ls(n, P(INF, -1)), rs(n, P(INF, -1)), dp(n);
function<void(Int, Int)> dfs = [&](Int l, Int r) -> void {
if (l + 1 == r) {
dp[l] = P(a[l], l);
return;
}
Int m = (l + r) >> 1;
dfs(l, m);
dfs(m, r);
P x(INF, -1), y(INF, -1);
for (Int i = l, j = m; i < m || j < r;) {
if (i < m && (j == r || dp[i].first <= dp[j].first)) {
Int k = dp[i++].second;
chmin(rs[k], y);
chmin(x, P(a[k] - k * d, k));
} else {
Int k = dp[j++].second;
chmin(ls[k], x);
chmin(y, P(a[k] + k * d, k));
}
}
inplace_merge(dp.begin() + l, dp.begin() + m, dp.begin() + r);
};
dfs(0, n);
auto add_edge = [&](Int x, Int y) {
if (x < 0 || y < 0)
return;
Int c = abs(x - y) * d + a[x] + a[y];
ks.add_edge(x, y, c);
};
for (Int i = 0; i < n; i++)
add_edge(ls[i].second, i);
for (Int i = 0; i < n; i++)
add_edge(i, rs[i].second);
cout << ks.build() << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 954,571 | 954,572 | u687214625 | cpp |
p03153 | #include <bits/stdc++.h>
#define F first
#define S second
using namespace std;
typedef long double ld;
typedef long long ll;
const int max_n = 300011, max_m = 500011, inf = 1000111222;
const ll inff = 1000111222333444;
struct dsu {
int p[max_n], sz[max_n];
dsu() {
for (int i = 0; i < max_n; ++i) {
p[i] = i;
sz[i] = 1;
}
}
int find_set(int x) {
if (p[x] == x)
return x;
return p[x] = find_set(p[x]);
}
void union_set(int x, int y) {
x = find_set(x);
y = find_set(y);
if (x != y) {
if (sz[x] < sz[y])
swap(x, y);
p[y] = x;
sz[x] += sz[y];
}
}
};
int n, a[max_n], d;
vector<pair<ll, pair<int, int>>> edges;
dsu dd;
ll dist(int i, int q) { return 1LL * abs(i - q) * d + a[i] + a[q]; }
void dev(int l, int r) {
if (l + 1 == r) {
return;
}
int mid = (l + r) / 2;
pair<ll, int> cv1, cv2;
cv1 = cv2 = {inff, 0};
for (int i = l; i < mid; ++i) {
cv1 = min(cv1, {a[i] - 1LL * d * i, i});
}
for (int i = mid; i < r; ++i) {
cv2 = min(cv1, {a[i] + 1LL * d * i, i});
}
for (int i = l; i < mid; ++i)
edges.push_back({dist(i, cv2.S), {i, cv2.S}});
for (int i = mid; i < r; ++i)
edges.push_back({dist(i, cv1.S), {i, cv1.S}});
dev(l, mid);
dev(mid, r);
}
int main() {
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
cin >> n >> d;
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
dev(0, n);
sort(edges.begin(), edges.end());
ll ans = 0;
for (int i = 0; i < edges.size(); ++i) {
if (dd.find_set(edges[i].S.F) != dd.find_set(edges[i].S.S)) {
dd.union_set(edges[i].S.F, edges[i].S.S);
ans += edges[i].F;
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define F first
#define S second
using namespace std;
typedef long double ld;
typedef long long ll;
const int max_n = 300011, max_m = 500011, inf = 1000111222;
const ll inff = 1000111222333444;
struct dsu {
int p[max_n], sz[max_n];
dsu() {
for (int i = 0; i < max_n; ++i) {
p[i] = i;
sz[i] = 1;
}
}
int find_set(int x) {
if (p[x] == x)
return x;
return p[x] = find_set(p[x]);
}
void union_set(int x, int y) {
x = find_set(x);
y = find_set(y);
if (x != y) {
if (sz[x] < sz[y])
swap(x, y);
p[y] = x;
sz[x] += sz[y];
}
}
};
int n, a[max_n], d;
vector<pair<ll, pair<int, int>>> edges;
dsu dd;
ll dist(int i, int q) { return 1LL * abs(i - q) * d + a[i] + a[q]; }
void dev(int l, int r) {
if (l + 1 == r) {
return;
}
int mid = (l + r) / 2;
pair<ll, int> cv1, cv2;
cv1 = cv2 = {inff, 0};
for (int i = l; i < mid; ++i) {
cv1 = min(cv1, {a[i] - 1LL * d * i, i});
}
for (int i = mid; i < r; ++i) {
cv2 = min(cv2, {a[i] + 1LL * d * i, i});
}
for (int i = l; i < mid; ++i)
edges.push_back({dist(i, cv2.S), {i, cv2.S}});
for (int i = mid; i < r; ++i)
edges.push_back({dist(i, cv1.S), {i, cv1.S}});
dev(l, mid);
dev(mid, r);
}
int main() {
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
cin >> n >> d;
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
dev(0, n);
sort(edges.begin(), edges.end());
ll ans = 0;
for (int i = 0; i < edges.size(); ++i) {
if (dd.find_set(edges[i].S.F) != dd.find_set(edges[i].S.S)) {
dd.union_set(edges[i].S.F, edges[i].S.S);
ans += edges[i].F;
}
}
cout << ans << endl;
return 0;
}
| [
"assignment.value.change",
"identifier.change",
"call.arguments.change"
] | 954,575 | 954,576 | u434758757 | cpp |
p03153 | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define fi first
#define se second
#define ll long long
#define pq priority_queue
#define mp make_pair
#define pii pair<int, int>
#define mod 998244353
int lowbit(int x) { return x & (-x); }
int n, d;
int a[200010];
vector<pair<ll, pii>> e;
struct UF {
int p[200010], rank[200010];
void init() {
for (int i = 0; i < 200010; i++)
p[i] = i;
for (int i = 0; i < 200010; i++)
rank[i] = 0;
}
int getf(int x) {
if (p[x] == x)
return x;
return getf(p[x]);
}
bool same(int x, int y) { return getf(x) == getf(y); }
void unite(int x, int y) {
int xx = getf(x);
int yy = getf(y);
if (xx != yy) {
if (rank[xx] < rank[yy])
p[xx] = yy;
else {
p[yy] = xx;
if (rank[xx] == rank[yy])
rank[xx]++;
}
}
}
} uf;
void solve(int l, int r) {
if (l == r)
return;
int mid = l + r >> 1;
ll mn = 1e18;
int pl, pr;
for (int i = l; i <= mid; i++) {
ll cur = (ll)a[i] - (ll)d * (ll)i;
if (cur < mn) {
mn = cur;
pl = i;
}
}
mn = 1e18;
for (int j = mid + 1; j <= r; j++) {
ll cur = a[j] - (ll)d * (ll)j;
if (cur < mn) {
mn = cur;
pr = j;
}
}
for (int i = mid + 1; i <= r; i++) {
ll vl = (ll)a[pl] - (ll)d * (ll)pl;
ll vr = (ll)a[i] + (ll)d * (ll)i;
e.pb(mp(vl + vr, mp(pl, i)));
}
for (int i = l; i <= mid; i++) {
ll vl = (ll)a[i] - (ll)d * (ll)i;
ll vr = (ll)a[pr] + (ll)d * (ll)pr;
e.pb(mp(vl + vr, mp(i, pr)));
}
solve(l, mid);
solve(mid + 1, r);
}
int main() {
scanf("%d%d", &n, &d);
for (int i = 0; i < n; i++)
scanf("%d", &a[i]);
solve(0, n - 1);
sort(e.begin(), e.end());
uf.init();
ll ans = 0ll;
for (int i = 0; i < e.size(); i++) {
int u = e[i].se.fi, v = e[i].se.se;
if (!uf.same(u, v)) {
uf.unite(u, v);
ans += e[i].fi;
// cout<<e[i].fi<<" "<<u<<" "<<v<<endl;
}
}
cout << ans;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define fi first
#define se second
#define ll long long
#define pq priority_queue
#define mp make_pair
#define pii pair<int, int>
#define mod 998244353
int lowbit(int x) { return x & (-x); }
int n, d;
int a[200010];
vector<pair<ll, pii>> e;
struct UF {
int p[200010], rank[200010];
void init() {
for (int i = 0; i < 200010; i++)
p[i] = i;
for (int i = 0; i < 200010; i++)
rank[i] = 0;
}
int getf(int x) {
if (p[x] == x)
return x;
return getf(p[x]);
}
bool same(int x, int y) { return getf(x) == getf(y); }
void unite(int x, int y) {
int xx = getf(x);
int yy = getf(y);
if (xx != yy) {
if (rank[xx] < rank[yy])
p[xx] = yy;
else {
p[yy] = xx;
if (rank[xx] == rank[yy])
rank[xx]++;
}
}
}
} uf;
void solve(int l, int r) {
if (l == r)
return;
int mid = l + r >> 1;
ll mn = 1e18;
int pl, pr;
for (int i = l; i <= mid; i++) {
ll cur = (ll)a[i] - (ll)d * (ll)i;
if (cur < mn) {
mn = cur;
pl = i;
}
}
mn = 1e18;
for (int j = mid + 1; j <= r; j++) {
ll cur = a[j] + (ll)d * (ll)j;
if (cur < mn) {
mn = cur;
pr = j;
}
}
for (int i = mid + 1; i <= r; i++) {
ll vl = (ll)a[pl] - (ll)d * (ll)pl;
ll vr = (ll)a[i] + (ll)d * (ll)i;
e.pb(mp(vl + vr, mp(pl, i)));
}
for (int i = l; i <= mid; i++) {
ll vl = (ll)a[i] - (ll)d * (ll)i;
ll vr = (ll)a[pr] + (ll)d * (ll)pr;
e.pb(mp(vl + vr, mp(i, pr)));
}
solve(l, mid);
solve(mid + 1, r);
}
int main() {
scanf("%d%d", &n, &d);
for (int i = 0; i < n; i++)
scanf("%d", &a[i]);
solve(0, n - 1);
sort(e.begin(), e.end());
uf.init();
ll ans = 0ll;
for (int i = 0; i < e.size(); i++) {
int u = e[i].se.fi, v = e[i].se.se;
if (!uf.same(u, v)) {
uf.unite(u, v);
ans += e[i].fi;
// cout<<e[i].fi<<" "<<u<<" "<<v<<endl;
}
}
cout << ans;
return 0;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"expression.operation.binary.change"
] | 954,611 | 954,612 | u068829283 | cpp |
p03153 | #include <algorithm>
#include <assert.h>
#include <bits/stdc++.h>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdlib.h>
#include <time.h>
#include <utility>
#include <vector>
using namespace std;
#define SIZE 200005
#define INF 1000000000000000000ll
typedef long long ll;
typedef pair<int, int> P;
typedef pair<ll, P> PP;
struct UF {
int par[SIZE], rank[SIZE];
void init(int n) {
for (int i = 0; i < n; i++) {
par[i] = i;
rank[i] = 0;
}
}
int find(int x) {
if (par[x] == x)
return x;
return par[x] = find(par[x]);
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (rank[x] < rank[y])
par[x] = y;
else {
par[y] = x;
if (rank[x] == rank[y])
rank[x]++;
}
}
bool same(int x, int y) { return find(x) == find(y); }
} uf;
ll A[SIZE];
ll D;
vector<PP> edge;
void solve(int l, int r) {
if (l == r)
return;
int m = (l + r) / 2;
ll mn = INF;
int pl = -1;
for (int i = l; i <= m; i++) {
ll vl = A[i] - D * (ll)i;
if (mn > vl) {
mn = vl;
pl = i;
}
}
mn = INF;
int pr = -1;
for (int i = m + 1; i <= r; i++) {
ll vl = A[i] + D * (ll)i;
if (mn > vl) {
mn = vl;
pr = i;
}
}
for (int i = 1; i <= m; i++) {
ll vl = A[i] - D * (ll)i;
ll vr = A[pr] + D * (ll)pr;
edge.push_back(PP(vl + vr, P(i, pr)));
}
for (int i = m + 1; i <= r; i++) {
ll vl = A[pl] - D * (ll)pl;
ll vr = A[i] + D * (ll)i;
edge.push_back(PP(vl + vr, P(pl, i)));
}
solve(l, m);
solve(m + 1, r);
}
int main() {
int n;
scanf("%d%lld", &n, &D);
for (int i = 0; i < n; i++)
scanf("%lld", &A[i]);
solve(0, n - 1);
sort(edge.begin(), edge.end());
uf.init(n + 2);
ll ret = 0;
for (int i = 0; i < edge.size(); i++) {
P p = edge[i].second;
if (!uf.same(p.first, p.second)) {
uf.unite(p.first, p.second);
ret += edge[i].first;
}
}
printf("%lld", ret);
} | #include <algorithm>
#include <assert.h>
#include <bits/stdc++.h>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdlib.h>
#include <time.h>
#include <utility>
#include <vector>
using namespace std;
#define SIZE 200005
#define INF 10000000000000000LL
typedef long long ll;
typedef pair<int, int> P;
typedef pair<ll, P> PP;
struct UF {
int par[SIZE], rank[SIZE];
void init(int n) {
for (int i = 0; i < n; i++) {
par[i] = i;
rank[i] = 0;
}
}
int find(int x) {
if (par[x] == x)
return x;
return par[x] = find(par[x]);
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (rank[x] < rank[y])
par[x] = y;
else {
par[y] = x;
if (rank[x] == rank[y])
rank[x]++;
}
}
bool same(int x, int y) { return find(x) == find(y); }
} uf;
ll A[SIZE];
ll D;
vector<PP> edge;
void solve(int l, int r) {
if (l == r)
return;
int m = (l + r) / 2;
ll mn = INF;
int pl = -1;
for (int i = l; i <= m; i++) {
ll vl = A[i] - D * (ll)i;
if (mn > vl) {
mn = vl;
pl = i;
}
}
mn = INF;
int pr = -1;
for (int i = m + 1; i <= r; i++) {
ll vl = A[i] + D * (ll)i;
if (mn > vl) {
mn = vl;
pr = i;
}
}
for (int i = l; i <= m; i++) {
ll vl = A[i] - D * (ll)i;
ll vr = A[pr] + D * (ll)pr;
edge.push_back(PP(vl + vr, P(i, pr)));
}
for (int i = m + 1; i <= r; i++) {
ll vl = A[pl] - D * (ll)pl;
ll vr = A[i] + D * (ll)i;
edge.push_back(PP(vl + vr, P(pl, i)));
}
solve(l, m);
solve(m + 1, r);
}
int main() {
int n;
scanf("%d%lld", &n, &D);
for (int i = 0; i < n; i++)
scanf("%lld", &A[i]);
solve(0, n - 1);
sort(edge.begin(), edge.end());
uf.init(n + 2);
ll ret = 0;
for (int i = 0; i < edge.size(); i++) {
P p = edge[i].second;
if (!uf.same(p.first, p.second)) {
uf.unite(p.first, p.second);
ret += edge[i].first;
}
}
printf("%lld", ret);
return 0;
} | [
"variable_declaration.value.change",
"identifier.replace.add",
"literal.replace.remove",
"control_flow.loop.for.initializer.change",
"control_flow.return.add",
"control_flow.return.0.add"
] | 954,625 | 954,626 | u937608388 | cpp |
p03153 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <vector>
using namespace std;
long long n, d, a[200005];
typedef pair<int, int> P;
typedef pair<long long, P> PP;
struct UF {
int par[200005], rank[200005];
void init(int n) {
for (int i = 0; i < n; i++) {
par[i] = i;
rank[i] = 0;
}
}
int find(int x) {
if (par[x] == x)
return x;
return par[x] = find(par[x]);
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (rank[x] < rank[y])
par[x] = y;
else {
par[y] = x;
if (rank[x] == rank[y])
rank[x]++;
}
}
bool same(int x, int y) { return find(x) == find(y); }
} uf;
vector<PP> edge;
void solve(int l, int r) {
if (l == r)
return;
// cout<<l<<' '<<r<<endl;
int m = (l + r) / 2;
long long mn = 2e18;
int pl = -1;
for (int i = l; i <= m; i++) {
long long vl = a[i] - d * (long long)i;
if (mn > vl) {
mn = vl;
pl = i;
}
}
mn = 2e18;
int pr = -1;
for (int i = m + 1; i <= r; i++) {
long long vl = a[i] + d * (long long)i;
if (mn > vl) {
mn = vl;
pr = i;
}
}
for (int i = 1; i <= m; i++) {
long long vl = a[i] - d * (long long)i;
long long vr = a[pr] + d * (long long)pr;
edge.push_back(PP(vl + vr, P(i, pr)));
}
for (int i = m + 1; i <= r; i++) {
long long vl = a[pl] - d * (long long)pl;
long long vr = a[i] + d * (long long)i;
edge.push_back(PP(vl + vr, P(pl, i)));
}
solve(l, m);
solve(m + 1, r);
}
int main() {
scanf("%lld%lld", &n, &d);
for (int i = 0; i < n; i++)
scanf("%lld", &a[i]);
solve(0, n - 1);
sort(edge.begin(), edge.end());
uf.init(n + 2);
long long ret = 0;
for (int i = 0; i < edge.size(); i++) {
P p = edge[i].second;
// cout<<p.first<<' '<<p.second<<endl;
if (!uf.same(p.first, p.second)) {
// cout<<p.first<<' '<<p.second<<endl;
uf.unite(p.first, p.second);
ret += edge[i].first;
}
}
cout << ret;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <vector>
using namespace std;
long long n, d, a[200005];
typedef pair<int, int> P;
typedef pair<long long, P> PP;
struct UF {
int par[200005], rank[200005];
void init(int n) {
for (int i = 0; i < n; i++) {
par[i] = i;
rank[i] = 0;
}
}
int find(int x) {
if (par[x] == x)
return x;
return par[x] = find(par[x]);
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (rank[x] < rank[y])
par[x] = y;
else {
par[y] = x;
if (rank[x] == rank[y])
rank[x]++;
}
}
bool same(int x, int y) { return find(x) == find(y); }
} uf;
vector<PP> edge;
void solve(int l, int r) {
if (l == r)
return;
// cout<<l<<' '<<r<<endl;
int m = (l + r) / 2;
long long mn = 2e18;
int pl = -1;
for (int i = l; i <= m; i++) {
long long vl = a[i] - d * (long long)i;
if (mn > vl) {
mn = vl;
pl = i;
}
}
mn = 2e18;
int pr = -1;
for (int i = m + 1; i <= r; i++) {
long long vl = a[i] + d * (long long)i;
if (mn > vl) {
mn = vl;
pr = i;
}
}
for (int i = l; i <= m; i++) {
long long vl = a[i] - d * (long long)i;
long long vr = a[pr] + d * (long long)pr;
edge.push_back(PP(vl + vr, P(i, pr)));
}
for (int i = m + 1; i <= r; i++) {
long long vl = a[pl] - d * (long long)pl;
long long vr = a[i] + d * (long long)i;
edge.push_back(PP(vl + vr, P(pl, i)));
}
solve(l, m);
solve(m + 1, r);
}
int main() {
scanf("%lld%lld", &n, &d);
for (int i = 0; i < n; i++)
scanf("%lld", &a[i]);
solve(0, n - 1);
sort(edge.begin(), edge.end());
uf.init(n + 2);
long long ret = 0;
for (int i = 0; i < edge.size(); i++) {
P p = edge[i].second;
// cout<<p.first<<' '<<p.second<<endl;
if (!uf.same(p.first, p.second)) {
// cout<<p.first<<' '<<p.second<<endl;
uf.unite(p.first, p.second);
ret += edge[i].first;
}
}
cout << ret;
return 0;
} | [
"variable_declaration.value.change",
"identifier.replace.add",
"literal.replace.remove",
"control_flow.loop.for.initializer.change"
] | 954,629 | 954,630 | u936665693 | cpp |
p03153 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll run();
int main() {
#ifdef home
freopen("i", "r", stdin);
freopen("d", "w", stderr);
#endif
cout.precision(15);
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
run();
return 0;
}
ll n, d, m;
ll a[200005], pre[200005];
struct edge {
ll u, v;
ll w;
edge() {}
edge(ll u, ll v, ll w) : u(u), v(v), w(w) {}
bool operator<(const edge &other) const { return w < other.w; }
};
edge edges[200005 * 30];
void add(ll l, ll r) {
if (l == r)
return;
ll mid = (l + r) >> 1;
ll min = LLONG_MAX;
ll pos = -1;
for (ll i = l; i <= mid; i++) {
ll f = a[i] - i * d;
if (f < min) {
min = f;
pos = i;
}
}
for (ll i = mid + 1; i <= r; i++) {
edges[m++] = edge(pos, i, (i - pos) * d + a[i] + a[pos]);
}
min = LLONG_MAX;
pos = -1;
for (ll i = mid + 1; i <= r; i++) {
ll f = a[i] + i * d;
if (f < min) {
min = f;
pos = i;
}
}
for (ll i = l; i <= mid; i++) {
edges[m++] = edge(pos, i, a[pos] + a[i] + d * (pos - i));
}
add(l, mid);
add(mid + 1, r);
}
ll find(ll x) {
if (0 == pre[x])
return x;
return pre[x] = find(pre[x]);
}
ll kruskal() {
memset(pre, 0, sizeof(pre));
sort(edges + 1, edges + m + 1);
ll cnt = 1;
ll res = 0;
for (ll i = 1; i <= m; i++) {
ll u = edges[i].u;
ll v = edges[i].v;
ll w = edges[i].w;
ll fu = find(u);
ll fv = find(v);
if (fu == fv)
continue;
pre[fu] = fv;
res += w;
++cnt;
if (cnt == n)
return res;
}
return res;
}
ll run() {
cin >> n >> d;
for (ll i = 1; i <= n; i++)
cin >> a[i];
add(1, n);
cout << kruskal();
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll run();
int main() {
#ifdef home
freopen("i", "r", stdin);
freopen("d", "w", stderr);
#endif
cout.precision(15);
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
run();
return 0;
}
ll n, d, m = 1;
ll a[200005], pre[200005];
struct edge {
ll u, v;
ll w;
edge() {}
edge(ll u, ll v, ll w) : u(u), v(v), w(w) {}
bool operator<(const edge &other) const { return w < other.w; }
};
edge edges[200005 * 30];
void add(ll l, ll r) {
if (l == r)
return;
ll mid = (l + r) >> 1;
ll min = LLONG_MAX;
ll pos = -1;
for (ll i = l; i <= mid; i++) {
ll f = a[i] - i * d;
if (f < min) {
min = f;
pos = i;
}
}
for (ll i = mid + 1; i <= r; i++) {
edges[m++] = edge(pos, i, (i - pos) * d + a[i] + a[pos]);
}
min = LLONG_MAX;
pos = -1;
for (ll i = mid + 1; i <= r; i++) {
ll f = a[i] + i * d;
if (f < min) {
min = f;
pos = i;
}
}
for (ll i = l; i <= mid; i++) {
edges[m++] = edge(pos, i, a[pos] + a[i] + d * (pos - i));
}
add(l, mid);
add(mid + 1, r);
}
ll find(ll x) {
if (0 == pre[x])
return x;
return pre[x] = find(pre[x]);
}
ll kruskal() {
memset(pre, 0, sizeof(pre));
sort(edges + 1, edges + m + 1);
ll cnt = 1;
ll res = 0;
for (ll i = 1; i <= m; i++) {
ll u = edges[i].u;
ll v = edges[i].v;
ll w = edges[i].w;
ll fu = find(u);
ll fv = find(v);
if (fu == fv)
continue;
pre[fu] = fv;
res += w;
++cnt;
if (cnt == n)
return res;
}
return res;
}
ll run() {
cin >> n >> d;
for (ll i = 1; i <= n; i++)
cin >> a[i];
add(1, n);
cout << kruskal();
}
| [
"variable_declaration.value.change"
] | 954,647 | 954,648 | u244818078 | cpp |
p03153 | #include <bits/stdc++.h>
#define pb push_back
#define int long long
typedef long long ll;
using namespace std;
const int MAX = 2e5 + 5;
int id[MAX], nodes, edges;
typedef pair<ll, ll> pll;
pair<long long, pair<int, int>> p[MAX];
void initialize() {
for (int i = 0; i < MAX; ++i)
id[i] = i;
}
int root(int x) {
while (id[x] != x) {
id[x] = id[id[x]];
x = id[x];
}
return x;
}
void union1(int x, int y) {
int p = root(x);
int q = root(y);
id[p] = id[q];
}
long long kruskal(vector<pair<long long, pair<int, int>>> p) {
int x, y;
long long cost, minimumCost = 0;
edges = p.size();
for (int i = 0; i < edges; ++i) {
// Selecting edges one by one in increasing order from the beginning
x = p[i].second.first;
y = p[i].second.second;
cost = p[i].first;
// Check if the selected edge is creating a cycle or not
if (root(x) != root(y)) {
minimumCost += cost;
union1(x, y);
}
}
return minimumCost;
}
ll n, D;
ll a[200005];
const ll inf = 1e16;
map<ll, ll> mp;
map<ll, ll> rmp;
ll N;
void solve(ll l, ll r, vector<pair<ll, pll>> &e) {
ll mid = (l + r) / 2;
ll id1 = -1;
ll id2 = -1;
if (l == r)
return;
ll mnm = 1e16;
for (ll i = l; i <= mid; i++) {
if (mnm > a[i] - i * D) {
mnm = a[i] - i * D;
id1 = i;
}
}
mnm = 1e16;
for (ll i = mid + 1; i <= r; i++) {
if (mnm > a[i] - i * D) {
mnm = a[i] + i * D;
id2 = i;
}
}
for (ll i = mid + 1; i <= r; i++) {
e.pb(make_pair(a[i] + a[id1] + (i - id1) * D, make_pair(i, id1)));
}
for (ll i = l; i <= mid; i++) {
e.pb(make_pair(a[i] + a[id2] + (id2 - i) * D, make_pair(i, id2)));
}
solve(l, mid, e);
solve(mid + 1, r, e);
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> D;
initialize();
vector<pair<ll, ll>> v;
vector<ll> aa;
for (ll i = 1; i <= n; i++) {
cin >> a[i];
v.pb(make_pair(a[i], i));
aa.pb(a[i]);
}
sort(aa.begin(), aa.end());
ll sz = unique(aa.begin(), aa.end()) - aa.begin();
aa.resize(sz);
for (ll i = 0; i < sz; i++) {
mp[aa[i]] = i + 1;
rmp[i + 1] = aa[i];
}
N = 5 * sz;
sort(v.begin(), v.end());
vector<pair<ll, pll>> e;
solve(1, n, e);
sort(e.begin(), e.end());
ll ans = kruskal(e);
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define pb push_back
#define int long long
typedef long long ll;
using namespace std;
const int MAX = 2e5 + 5;
int id[MAX], nodes, edges;
typedef pair<ll, ll> pll;
pair<long long, pair<int, int>> p[MAX];
void initialize() {
for (int i = 0; i < MAX; ++i)
id[i] = i;
}
int root(int x) {
while (id[x] != x) {
id[x] = id[id[x]];
x = id[x];
}
return x;
}
void union1(int x, int y) {
int p = root(x);
int q = root(y);
id[p] = id[q];
}
long long kruskal(vector<pair<long long, pair<int, int>>> p) {
int x, y;
long long cost, minimumCost = 0;
edges = p.size();
for (int i = 0; i < edges; ++i) {
// Selecting edges one by one in increasing order from the beginning
x = p[i].second.first;
y = p[i].second.second;
cost = p[i].first;
// Check if the selected edge is creating a cycle or not
if (root(x) != root(y)) {
minimumCost += cost;
union1(x, y);
}
}
return minimumCost;
}
ll n, D;
ll a[200005];
const ll inf = 1e16;
map<ll, ll> mp;
map<ll, ll> rmp;
ll N;
void solve(ll l, ll r, vector<pair<ll, pll>> &e) {
ll mid = (l + r) / 2;
ll id1 = -1;
ll id2 = -1;
if (l == r)
return;
ll mnm = 1e16;
for (ll i = l; i <= mid; i++) {
if (mnm > a[i] - i * D) {
mnm = a[i] - i * D;
id1 = i;
}
}
mnm = 1e16;
for (ll i = mid + 1; i <= r; i++) {
if (mnm > a[i] + i * D) {
mnm = a[i] + i * D;
id2 = i;
}
}
for (ll i = mid + 1; i <= r; i++) {
e.pb(make_pair(a[i] + a[id1] + (i - id1) * D, make_pair(i, id1)));
}
for (ll i = l; i <= mid; i++) {
e.pb(make_pair(a[i] + a[id2] + (id2 - i) * D, make_pair(i, id2)));
}
solve(l, mid, e);
solve(mid + 1, r, e);
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> D;
initialize();
vector<pair<ll, ll>> v;
vector<ll> aa;
for (ll i = 1; i <= n; i++) {
cin >> a[i];
v.pb(make_pair(a[i], i));
aa.pb(a[i]);
}
sort(aa.begin(), aa.end());
ll sz = unique(aa.begin(), aa.end()) - aa.begin();
aa.resize(sz);
for (ll i = 0; i < sz; i++) {
mp[aa[i]] = i + 1;
rmp[i + 1] = aa[i];
}
N = 5 * sz;
sort(v.begin(), v.end());
vector<pair<ll, pll>> e;
solve(1, n, e);
sort(e.begin(), e.end());
ll ans = kruskal(e);
cout << ans << endl;
return 0;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change"
] | 954,659 | 954,660 | u116436282 | cpp |
p03153 | #include <bits/stdc++.h>
#define pb push_back
#define int long long
typedef long long ll;
using namespace std;
const int MAX = 2e5 + 5;
int id[MAX], nodes, edges;
typedef pair<ll, ll> pll;
pair<long long, pair<int, int>> p[MAX];
void initialize() {
for (int i = 0; i < MAX; ++i)
id[i] = i;
}
int root(int x) {
while (id[x] != x) {
id[x] = id[id[x]];
x = id[x];
}
return x;
}
void union1(int x, int y) {
int p = root(x);
int q = root(y);
id[p] = id[q];
}
long long kruskal(vector<pair<long long, pair<int, int>>> p) {
int x, y;
long long cost, minimumCost = 0;
edges = p.size();
for (int i = 0; i < edges; ++i) {
// Selecting edges one by one in increasing order from the beginning
x = p[i].second.first;
y = p[i].second.second;
cost = p[i].first;
// Check if the selected edge is creating a cycle or not
if (root(x) != root(y)) {
minimumCost += cost;
union1(x, y);
}
}
return minimumCost;
}
ll n, D;
ll a[200005];
const ll inf = 1e16;
map<ll, ll> mp;
map<ll, ll> rmp;
ll N;
void solve(ll l, ll r, vector<pair<ll, pll>> &e) {
ll mid = (l + r) / 2;
ll id1 = -1;
ll id2 = -1;
if (l == r)
return;
ll mnm = 1e16;
for (ll i = l; i <= mid; i++) {
if (mnm > a[i] - i * D) {
mnm = a[i] - i * D;
id1 = i;
}
}
mnm = 1e16;
for (ll i = mid + 1; i <= r; i++) {
if (mnm > a[i] - i * D) {
mnm = a[i] - i * D;
id2 = i;
}
}
for (ll i = mid + 1; i <= r; i++) {
e.pb(make_pair(a[i] + a[id1] + (i - id1) * D, make_pair(i, id1)));
}
for (ll i = l; i <= mid; i++) {
e.pb(make_pair(a[i] + a[id2] + (id2 - i) * D, make_pair(i, id2)));
}
solve(l, mid, e);
solve(mid + 1, r, e);
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> D;
initialize();
vector<pair<ll, ll>> v;
vector<ll> aa;
for (ll i = 1; i <= n; i++) {
cin >> a[i];
v.pb(make_pair(a[i], i));
aa.pb(a[i]);
}
sort(aa.begin(), aa.end());
ll sz = unique(aa.begin(), aa.end()) - aa.begin();
aa.resize(sz);
for (ll i = 0; i < sz; i++) {
mp[aa[i]] = i + 1;
rmp[i + 1] = aa[i];
}
N = 5 * sz;
sort(v.begin(), v.end());
vector<pair<ll, pll>> e;
solve(1, n, e);
sort(e.begin(), e.end());
ll ans = kruskal(e);
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define pb push_back
#define int long long
typedef long long ll;
using namespace std;
const int MAX = 2e5 + 5;
int id[MAX], nodes, edges;
typedef pair<ll, ll> pll;
pair<long long, pair<int, int>> p[MAX];
void initialize() {
for (int i = 0; i < MAX; ++i)
id[i] = i;
}
int root(int x) {
while (id[x] != x) {
id[x] = id[id[x]];
x = id[x];
}
return x;
}
void union1(int x, int y) {
int p = root(x);
int q = root(y);
id[p] = id[q];
}
long long kruskal(vector<pair<long long, pair<int, int>>> p) {
int x, y;
long long cost, minimumCost = 0;
edges = p.size();
for (int i = 0; i < edges; ++i) {
// Selecting edges one by one in increasing order from the beginning
x = p[i].second.first;
y = p[i].second.second;
cost = p[i].first;
// Check if the selected edge is creating a cycle or not
if (root(x) != root(y)) {
minimumCost += cost;
union1(x, y);
}
}
return minimumCost;
}
ll n, D;
ll a[200005];
const ll inf = 1e16;
map<ll, ll> mp;
map<ll, ll> rmp;
ll N;
void solve(ll l, ll r, vector<pair<ll, pll>> &e) {
ll mid = (l + r) / 2;
ll id1 = -1;
ll id2 = -1;
if (l == r)
return;
ll mnm = 1e16;
for (ll i = l; i <= mid; i++) {
if (mnm > a[i] - i * D) {
mnm = a[i] - i * D;
id1 = i;
}
}
mnm = 1e16;
for (ll i = mid + 1; i <= r; i++) {
if (mnm > a[i] + i * D) {
mnm = a[i] + i * D;
id2 = i;
}
}
for (ll i = mid + 1; i <= r; i++) {
e.pb(make_pair(a[i] + a[id1] + (i - id1) * D, make_pair(i, id1)));
}
for (ll i = l; i <= mid; i++) {
e.pb(make_pair(a[i] + a[id2] + (id2 - i) * D, make_pair(i, id2)));
}
solve(l, mid, e);
solve(mid + 1, r, e);
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> D;
initialize();
vector<pair<ll, ll>> v;
vector<ll> aa;
for (ll i = 1; i <= n; i++) {
cin >> a[i];
v.pb(make_pair(a[i], i));
aa.pb(a[i]);
}
sort(aa.begin(), aa.end());
ll sz = unique(aa.begin(), aa.end()) - aa.begin();
aa.resize(sz);
for (ll i = 0; i < sz; i++) {
mp[aa[i]] = i + 1;
rmp[i + 1] = aa[i];
}
N = 5 * sz;
sort(v.begin(), v.end());
vector<pair<ll, pll>> e;
solve(1, n, e);
sort(e.begin(), e.end());
ll ans = kruskal(e);
cout << ans << endl;
return 0;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 954,661 | 954,660 | u116436282 | cpp |
p03160 | #include <cmath>
#include <complex>
#include <iostream>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
using i64 = int_fast64_t;
using u64 = uint_fast64_t;
using i32 = int_fast32_t;
using u32 = uint_fast32_t;
#define int i64
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 int INF = 1e5;
signed main() {
int n;
cin >> n;
vector<int> h(n, 0);
for (int i = 0; i < n; i++)
cin >> h[i];
vector<int> dp(n, INF);
dp[0] = 0;
dp[1] = abs(h[1] - h[0]);
for (int i = 2; i < n; i++) {
chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
cout << dp[n - 1] << endl;
return 0;
}
| #include <cmath>
#include <complex>
#include <iostream>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
using i64 = int_fast64_t;
using u64 = uint_fast64_t;
using i32 = int_fast32_t;
using u32 = uint_fast32_t;
#define int i64
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 int INF = 1LL << 60;
signed main() {
int n;
cin >> n;
vector<int> h(n, 0);
for (int i = 0; i < n; i++)
cin >> h[i];
vector<int> dp(n, INF);
dp[0] = 0;
dp[1] = abs(h[1] - h[0]);
for (int i = 2; i < n; i++) {
chmin(dp[i], dp[i - 1] + abs(h[i] - h[i - 1]));
chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
cout << dp[n - 1] << endl;
return 0;
}
| [
"literal.number.change"
] | 954,681 | 954,682 | u550913048 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int dp[114514];
int main() {
int n;
cin >> n;
vector<int> h(n);
for (int i = 0; i < n; i++) {
cin >> h[i];
dp[i] = 114514;
}
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= 2; j++) {
if (i >= j) {
dp[i] = min(dp[i - j] + abs(h[i] - h[i - j]), dp[i]);
}
}
}
cout << dp[n - 1] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int dp[114514];
int main() {
int n;
cin >> n;
vector<int> h(n);
for (int i = 0; i < n; i++) {
cin >> h[i];
dp[i] = 1145141919;
}
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= 2; j++) {
if (i >= j) {
dp[i] = min(dp[i - j] + abs(h[i] - h[i - j]), dp[i]);
}
}
}
cout << dp[n - 1] << endl;
return 0;
}
| [
"literal.number.change",
"assignment.value.change"
] | 954,683 | 954,684 | u110653681 | cpp |
p03160 | #include <bits/stdc++.h>
#define mp make_pair
#define pb push_back
#define rep(i, n) for (int i = 0; i < (n); i++)
#define reps(i, n, s) for (int i = (s); i < (n); i++)
#define MOD 1000000007
typedef long long ll;
using namespace std;
using Graph = vector<vector<int>>;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vector<int> h(N);
rep(i, N) cin >> h[i];
int MAX = 1000000;
vector<int> dp(N, MAX);
dp[0] = 0;
rep(i, N) {
for (int j : {i + 1, i + 2}) {
if (j < N) {
dp[j] = min(dp[j], dp[i] + abs(h[j] - h[i]));
}
}
// dp[i + 1] = min(dp[i + 1], dp[i] + abs(h[i + 1] - h[i]));
// dp[i + 2] = min(dp[i + 2], dp[i] + abs(h[i + 2] - h[i]));
}
std::cout << dp[N - 1] << endl;
// std::system("pause");
return 0;
} | #include <bits/stdc++.h>
#define mp make_pair
#define pb push_back
#define rep(i, n) for (int i = 0; i < (n); i++)
#define reps(i, n, s) for (int i = (s); i < (n); i++)
#define MOD 1000000007
typedef long long ll;
using namespace std;
using Graph = vector<vector<int>>;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vector<int> h(N);
rep(i, N) cin >> h[i];
int MAX = 1e9 + 7;
vector<int> dp(N, MAX);
dp[0] = 0;
rep(i, N) {
for (int j : {i + 1, i + 2}) {
if (j < N) {
dp[j] = min(dp[j], dp[i] + abs(h[j] - h[i]));
}
}
// dp[i + 1] = min(dp[i + 1], dp[i] + abs(h[i + 1] - h[i]));
// dp[i + 2] = min(dp[i + 2], dp[i] + abs(h[i + 2] - h[i]));
}
std::cout << dp[N - 1] << endl;
// std::system("pause");
return 0;
} | [
"literal.number.change"
] | 954,687 | 954,688 | u438265890 | cpp |
p03160 | // gauravsinghh
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
using bigint = int64_t;
#define pll pair<ll, ll>
#define vll vector<ll>
#define vpll vector<pll>
#define lob lower_bound
#define upb upper_bound
#define ff first
#define ss second
#define pb push_back
#define eb emplace_back
#define pf push_front
#define ins insert
#define mp make_pair
#define w(t) \
cin >> t; \
while (t--)
#define bitcount __builtin_popcount
#define endl "\n"
#define sz(s) (int)s.size()
#define mem(n, m) memset(n, m, sizeof(n))
#define deb(x) cout << #x << " = " << x << endl;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define ren(i, n) for (ll i = n - 1; i >= 0; i--)
#define all(x) x.begin(), x.end()
#define fo(i, a, b) for (ll i = a; i <= b; i++)
#define ffo(i, a, b) for (ll i = a; i >= b; i--)
#define ffi(i, a, b, c) for (ll i = a; i <= b; i += c)
#define IOS \
ios_base::sync_with_stdio(false); \
cin.tie(nullptr); \
cout.tie(nullptr);
const int MOD = 1000000007;
void io_set() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
ll n;
ll a[100005];
ll dp[100005];
ll func(ll i) {
if (i <= 1) {
return 0;
}
if (i == 2) {
dp[i] = abs(a[2] - a[1]);
return dp[i];
}
if (dp[i] != -1) {
return dp[i];
}
dp[i] = min(func(i - 1) + abs(a[i] - a[i - 1]),
func(i - 2) + abs(a[i] - a[i - 2]));
return dp[i];
}
void solve() {
cin >> n;
rep(i, n) { cin >> a[i + 1]; }
mem(dp, -1);
cout << func(n);
}
int main() {
IOS;
io_set();
ll tt = 1;
// cin >> tt;
while (tt--) {
solve();
}
return 0;
}
| // gauravsinghh
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
using bigint = int64_t;
#define pll pair<ll, ll>
#define vll vector<ll>
#define vpll vector<pll>
#define lob lower_bound
#define upb upper_bound
#define ff first
#define ss second
#define pb push_back
#define eb emplace_back
#define pf push_front
#define ins insert
#define mp make_pair
#define w(t) \
cin >> t; \
while (t--)
#define bitcount __builtin_popcount
#define endl "\n"
#define sz(s) (int)s.size()
#define mem(n, m) memset(n, m, sizeof(n))
#define deb(x) cout << #x << " = " << x << endl;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define ren(i, n) for (ll i = n - 1; i >= 0; i--)
#define all(x) x.begin(), x.end()
#define fo(i, a, b) for (ll i = a; i <= b; i++)
#define ffo(i, a, b) for (ll i = a; i >= b; i--)
#define ffi(i, a, b, c) for (ll i = a; i <= b; i += c)
#define IOS \
ios_base::sync_with_stdio(false); \
cin.tie(nullptr); \
cout.tie(nullptr);
const int MOD = 1000000007;
void io_set() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
ll n;
ll a[100005];
ll dp[100005];
ll func(ll i) {
if (i <= 1) {
return 0;
}
if (i == 2) {
dp[i] = abs(a[2] - a[1]);
return dp[i];
}
if (dp[i] != -1) {
return dp[i];
}
dp[i] = min(func(i - 1) + abs(a[i] - a[i - 1]),
func(i - 2) + abs(a[i] - a[i - 2]));
return dp[i];
}
void solve() {
cin >> n;
rep(i, n) { cin >> a[i + 1]; }
mem(dp, -1);
cout << func(n);
}
int main() {
IOS;
// io_set();
ll tt = 1;
// cin >> tt;
while (tt--) {
solve();
}
return 0;
}
| [
"call.remove"
] | 954,698 | 954,699 | u480527921 | cpp |
p03160 | // gauravsinghh
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define ll long long int
#define ld long double
#define db double
#define pii pair<int, int>
#define pll pair<long long, long long>
#define sii set<int>
#define sll set<long long>
#define vii vector<int>
#define vll vector<long long>
#define mii map<int, int>
#define mll map<long long, long long>
#define lob lower_bound
#define upb upper_bound
#define ff first
#define ss second
#define pb push_back
#define pf push_front
#define ins insert
#define mp make_pair
#define w(t) \
cin >> t; \
while (t--)
#define on cout << "\n"
#define o2(a, b) cout << a << " " << b
#define os cout << " "
#define bitcount __builtin_popcount
#define gcd __gcd
#define endl "\n"
#define present(s, x) (s.find(x) != s.end())
#define cpresent(s, x) (find(all(s), x) != s.end())
#define ford(container, it) \
for (__typeof(container.begin()) it = container.begin(); \
it != container.end(); it++)
#define fors(container, it, a, b) \
for (__typeof(container.begin()) it = a; it != b; it++)
#define MOD 1000000007
#define EPSILON 1e-9
#define PI 3.14159265358979323846
#define inf 999999999999999999
#define siz 100005
#define SIZ 1000005
#define SIZE 200005
#define fbo find_by_order
#define ook order_of_key
#define sz(s) (int)s.size()
#define mem(n, m) memset(n, m, sizeof(n))
#define rep(i, n) for (ll i = 0; i < n; i++)
#define ren(i, n) for (ll i = n - 1; i >= 0; i--)
#define all(x) x.begin(), x.end()
#define fo(i, a, b) for (ll i = a; i <= b; i++)
#define ffo(i, a, b) for (ll i = a; i >= b; i--)
#define MAX 100005
#define IOS \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
typedef tree<ll, null_type, less<ll>, rb_tree_tag,
tree_order_statistics_node_update>
pbds;
void io_set() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
ll n, dp[100005], a[100005];
ll func() {
dp[0] = 0;
dp[1] = abs(a[1] - a[0]);
fo(i, 2, n) {
dp[i] =
min(dp[i - 1] + abs(a[i] - a[i - 1]), dp[i - 2] + abs(a[i] - a[i - 2]));
}
return dp[n - 1];
}
signed main() {
IOS io_set();
cin >> n;
rep(i, n) { cin >> a[i]; }
cout << func() << endl;
return 0;
}
| // gauravsinghh
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define ll long long int
#define ld long double
#define db double
#define pii pair<int, int>
#define pll pair<long long, long long>
#define sii set<int>
#define sll set<long long>
#define vii vector<int>
#define vll vector<long long>
#define mii map<int, int>
#define mll map<long long, long long>
#define lob lower_bound
#define upb upper_bound
#define ff first
#define ss second
#define pb push_back
#define pf push_front
#define ins insert
#define mp make_pair
#define w(t) \
cin >> t; \
while (t--)
#define on cout << "\n"
#define o2(a, b) cout << a << " " << b
#define os cout << " "
#define bitcount __builtin_popcount
#define gcd __gcd
#define endl "\n"
#define present(s, x) (s.find(x) != s.end())
#define cpresent(s, x) (find(all(s), x) != s.end())
#define ford(container, it) \
for (__typeof(container.begin()) it = container.begin(); \
it != container.end(); it++)
#define fors(container, it, a, b) \
for (__typeof(container.begin()) it = a; it != b; it++)
#define MOD 1000000007
#define EPSILON 1e-9
#define PI 3.14159265358979323846
#define inf 999999999999999999
#define siz 100005
#define SIZ 1000005
#define SIZE 200005
#define fbo find_by_order
#define ook order_of_key
#define sz(s) (int)s.size()
#define mem(n, m) memset(n, m, sizeof(n))
#define rep(i, n) for (ll i = 0; i < n; i++)
#define ren(i, n) for (ll i = n - 1; i >= 0; i--)
#define all(x) x.begin(), x.end()
#define fo(i, a, b) for (ll i = a; i <= b; i++)
#define ffo(i, a, b) for (ll i = a; i >= b; i--)
#define MAX 100005
#define IOS \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
typedef tree<ll, null_type, less<ll>, rb_tree_tag,
tree_order_statistics_node_update>
pbds;
void io_set() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
ll n, dp[100005], a[100005];
ll func() {
dp[0] = 0;
dp[1] = abs(a[1] - a[0]);
fo(i, 2, n) {
dp[i] =
min(dp[i - 1] + abs(a[i] - a[i - 1]), dp[i - 2] + abs(a[i] - a[i - 2]));
}
return dp[n - 1];
}
signed main() {
IOS
// io_set();
cin >>
n;
rep(i, n) { cin >> a[i]; }
cout << func() << endl;
return 0;
}
| [
"variable_declaration.remove"
] | 954,700 | 954,701 | u480527921 | cpp |
p03160 | #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
//#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
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 = 0;
cin >> n;
vector<long long> dp(10);
vector<long long> h(n);
rep(i, n) cin >> h.at(i);
rep(i, dp.size()) dp.at(i) = INF;
dp.at(0) = 0;
for (int i = 1; i < n; i++) {
chmin(dp.at(i), dp.at(i - 1) + abs(h.at(i) - h.at(i - 1)));
if (i > 1) {
chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
}
cout << dp[n - 1];
} | #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
//#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
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 = 0;
cin >> n;
vector<long long> dp(n);
vector<long long> h(n);
rep(i, n) cin >> h.at(i);
rep(i, dp.size()) dp.at(i) = INF;
dp.at(0) = 0;
for (int i = 1; i < n; i++) {
chmin(dp.at(i), dp.at(i - 1) + abs(h.at(i) - h.at(i - 1)));
if (i > 1) {
chmin(dp[i], dp[i - 2] + abs(h[i] - h[i - 2]));
}
}
cout << dp[n - 1];
} | [
"call.arguments.change"
] | 954,702 | 954,703 | u739107267 | cpp |
p03160 | #include <bits/stdc++.h>
using namespace std;
// clang-format off
using LL = long long;
#define COUT(x) cout << #x << " = " << (x) << " (L" << __LINE__ << ")" << endl
#define REP(i,x) for(int i=0;i<(int)(x);i++)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();i++)
#define RFOR(i,c) for(__typeof((c).rbegin())i=(c).rbegin();i!=(c).rend();i++)
#define UNIQUE(v) v.erase( unique(v.begin(), v.end()), v.end() );
template<class T> ostream& operator<<(ostream &os, const vector<T> &t) {
os<<"["; FOR(it,t) {if(it!=t.begin()) os<<","; os<<*it;} os<<"]"; return os;
}
template<class T> ostream& operator<<(ostream &os, const set<T> &t) {
os<<"{"; FOR(it,t) {if(it!=t.begin()) os<<","; os<<*it;} os<<"}"; return os;
}
template<class S, class T> ostream& operator<<(ostream &os, const pair<S,T> &t) { return os<<"("<<t.first<<","<<t.second<<")";}
// clang-format on
void solve(long long N, std::vector<long long> h) {
// solver code
LL c[N];
c[0] = 0;
c[1] = abs(h[1] - h[0]);
for (int i = 2; i < N; i++) {
c[i] = min(c[i - 2] + abs(h[i] - h[i - 2]), c[i - 1] + abs(h[i] - h[i]));
}
cout << c[N - 1] << endl;
}
int main() {
long long N;
scanf("%lld", &N);
std::vector<long long> h(N);
for (int i = 0; i < N; i++) {
scanf("%lld", &h[i]);
}
solve(N, std::move(h));
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
// clang-format off
using LL = long long;
#define COUT(x) cout << #x << " = " << (x) << " (L" << __LINE__ << ")" << endl
#define REP(i,x) for(int i=0;i<(int)(x);i++)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();i++)
#define RFOR(i,c) for(__typeof((c).rbegin())i=(c).rbegin();i!=(c).rend();i++)
#define UNIQUE(v) v.erase( unique(v.begin(), v.end()), v.end() );
template<class T> ostream& operator<<(ostream &os, const vector<T> &t) {
os<<"["; FOR(it,t) {if(it!=t.begin()) os<<","; os<<*it;} os<<"]"; return os;
}
template<class T> ostream& operator<<(ostream &os, const set<T> &t) {
os<<"{"; FOR(it,t) {if(it!=t.begin()) os<<","; os<<*it;} os<<"}"; return os;
}
template<class S, class T> ostream& operator<<(ostream &os, const pair<S,T> &t) { return os<<"("<<t.first<<","<<t.second<<")";}
// clang-format on
void solve(long long N, std::vector<long long> h) {
// solver code
LL c[N];
c[0] = 0;
c[1] = abs(h[1] - h[0]);
for (int i = 2; i < N; i++) {
c[i] =
min(c[i - 2] + abs(h[i] - h[i - 2]), c[i - 1] + abs(h[i] - h[i - 1]));
}
cout << c[N - 1] << endl;
}
int main() {
long long N;
scanf("%lld", &N);
std::vector<long long> h(N);
for (int i = 0; i < N; i++) {
scanf("%lld", &h[i]);
}
solve(N, std::move(h));
return 0;
}
| [
"assignment.change"
] | 954,706 | 954,707 | u723574055 | cpp |
p03160 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int INF = 100000;
int main() {
int n;
cin >> n;
vector<int> hs(n);
rep(i, n) { cin >> hs[i]; }
vector<int> dp(n, INF);
dp[0] = 0;
for (int i = 1; i < n; i++) {
dp[i] = min(dp[i], dp[i - 1] + abs(hs[i] - hs[i - 1]));
if (1 < i) {
dp[i] = min(dp[i], dp[i - 2] + abs(hs[i] - hs[i - 2]));
}
}
int ans = dp[n - 1];
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int INF = 1000000000;
int main() {
int n;
cin >> n;
vector<int> hs(n);
rep(i, n) { cin >> hs[i]; }
vector<ll> dp(n, INF);
dp[0] = 0;
for (int i = 1; i < n; i++) {
dp[i] = min(dp[i], dp[i - 1] + abs(hs[i] - hs[i - 1]));
if (1 < i) {
dp[i] = min(dp[i], dp[i - 2] + abs(hs[i] - hs[i - 2]));
}
}
ll ans = dp[n - 1];
cout << ans << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change",
"variable_declaration.type.change"
] | 954,708 | 954,709 | u142082997 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.