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 |
|---|---|---|---|---|---|---|---|
p03161 | #include <iostream>
int abs(int a) { return (a > 0) ? a : -a; }
int main() {
int n, k;
std::cin >> n >> k;
int a[n], dp[n];
for (int i = 0; i < n; i++)
std::cin >> a[i];
dp[0] = 0;
for (int i = 1; i < n; i++) {
dp[i] = dp[i - 1] + abs(a[i] - a[i - 1]);
for (int j = 2; j <= k; j++) {
if (i > j - 1)
dp[i] = std::min(dp[i], dp[i - k] + abs(a[i - k] - a[i]));
}
}
std::cout << dp[n - 1] << std::endl;
return 0;
} | #include <iostream>
int abs(int a) { return (a > 0) ? a : -a; }
int main() {
int n, k;
std::cin >> n >> k;
int a[n], dp[n];
for (int i = 0; i < n; i++)
std::cin >> a[i];
dp[0] = 0;
for (int i = 1; i < n; i++) {
dp[i] = dp[i - 1] + abs(a[i] - a[i - 1]);
for (int j = 2; j <= k; j++) {
if (i >= j)
dp[i] = std::min(dp[i], dp[i - j] + abs(a[i - j] - a[i]));
}
}
std::cout << dp[n - 1] << std::endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove",
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.bi... | 959,882 | 959,883 | u387880194 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int N = 1e6 + 5;
#define ll long long
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define fr(i, l, m) for (int i = l; i < m; i++)
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll pwr(ll x, ll y);
bool isprime(ll x);
ll a[N], m[N];
// vector<int> ;
int main() {
ios_base::sync_with_stdio(false);
ll n, k;
cin >> n >> k;
fr(i, 0, n) { cin >> a[i]; }
for (int i = n - 2; i >= max(n - k, 0LL); i--) {
ll t = mod;
for (int j = i + 1; j <= n - 1; j++) {
t = min(abs(a[i] - a[j]), t);
}
m[i] = t;
}
// m[n-1]=(0);
// m[n-2]=abs(a[n-2]-a[n-1]);
for (int i = (n - k - 1); i >= 0; i--) {
ll t = mod;
for (int j = i + 1; j <= min(i + k, n - 1); j++) {
t = min(m[j] + abs(a[j] - a[i]), t);
}
m[i] = t;
}
cout << m[0] << endl;
// Code Here
return 0;
}
/////////
/////////
/////////
ll pwr(ll x, ll y) {
ll ans = 1;
x = x;
while (y > 0) {
if (y & 1)
ans = (x * ans);
x = (x * x);
y = y / 2;
}
return ans;
}
bool isprime(ll x) {
if (x < 2)
return false;
if (x < 4)
return true;
if (x % 2 == 0 || x % 3 == 0)
return false;
for (ll i = 5; i * i <= x; i += 6) {
if (x % i == 0 || x % (i + 2) == 0)
return false;
}
return true;
}
| #include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int N = 1e6 + 5;
#define ll long long
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define fr(i, l, m) for (int i = l; i < m; i++)
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll pwr(ll x, ll y);
bool isprime(ll x);
ll a[N], m[N];
// vector<int> ;
int main() {
ios_base::sync_with_stdio(false);
ll n, k;
cin >> n >> k;
fr(i, 0, n) { cin >> a[i]; }
for (int i = n - 2; i >= max(n - k, 0LL); i--) {
ll t = mod;
for (int j = i + 1; j <= n - 1; j++) {
t = min(m[j] + abs(a[i] - a[j]), t);
}
m[i] = t;
}
// m[n-1]=(0);
// m[n-2]=abs(a[n-2]-a[n-1]);
for (int i = (n - k - 1); i >= 0; i--) {
ll t = mod;
for (int j = i + 1; j <= min(i + k, n - 1); j++) {
t = min(m[j] + abs(a[j] - a[i]), t);
}
m[i] = t;
}
cout << m[0] << endl;
// Code Here
return 0;
}
/////////
/////////
/////////
ll pwr(ll x, ll y) {
ll ans = 1;
x = x;
while (y > 0) {
if (y & 1)
ans = (x * ans);
x = (x * x);
y = y / 2;
}
return ans;
}
bool isprime(ll x) {
if (x < 2)
return false;
if (x < 4)
return true;
if (x % 2 == 0 || x % 3 == 0)
return false;
for (ll i = 5; i * i <= x; i += 6) {
if (x % i == 0 || x % (i + 2) == 0)
return false;
}
return true;
}
| [
"assignment.change"
] | 959,887 | 959,888 | u131085615 | cpp |
p03161 | #include <bits/stdc++.h>
#define el_cucuy \
ios_base::sync_with_stdio(0), cout.tie(0); \
cin.tie(0);
#define llong long long
#define pb push_back
#define bpc __builtin_popcount
const llong mxn = 1e6 + 7;
const llong mod = 1e9 + 7;
const llong inf = 1e18 + 9;
using namespace std;
llong n, k, a[mxn], dp[mxn];
int main() {
el_cucuy cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
dp[1] = 0;
dp[2] = abs(a[1] - a[2]);
int m = k;
for (int i = 3; i <= n; i++) {
dp[i] = inf;
for (int j = 1; j <= min(i, m); j++) {
dp[i] = min(dp[i], dp[i - j] + abs(a[i] - a[i - j]));
}
}
cout << dp[n];
return 0;
}
| #include <bits/stdc++.h>
#define el_cucuy \
ios_base::sync_with_stdio(0), cout.tie(0); \
cin.tie(0);
#define llong long long
#define pb push_back
#define bpc __builtin_popcount
const llong mxn = 1e6 + 7;
const llong mod = 1e9 + 7;
const llong inf = 1e18 + 9;
using namespace std;
llong n, k, a[mxn], dp[mxn];
int main() {
el_cucuy cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
dp[1] = 0;
dp[2] = abs(a[1] - a[2]);
int m = k;
for (int i = 3; i <= n; i++) {
dp[i] = inf;
for (int j = 1; j <= min(i - 1, m); j++) {
dp[i] = min(dp[i], dp[i - j] + abs(a[i] - a[i - j]));
}
}
cout << dp[n];
return 0;
}
| [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 959,893 | 959,894 | u122292453 | cpp |
p03161 | #include <bits/stdc++.h>
#define el_cucuy \
ios_base::sync_with_stdio(0), cout.tie(0); \
cin.tie(0);
#define llong long long
#define pb push_back
#define bpc __builtin_popcount
const llong mxn = 1e6 + 7;
const llong mod = 1e9 + 7;
const llong inf = 1e18 + 9;
using namespace std;
llong n, k, a[mxn], dp[mxn];
int main() {
el_cucuy cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
dp[1] = 0;
dp[2] = abs(a[1] - a[2]);
for (int i = 3; i <= n; i++)
dp[i] = inf;
for (llong i = 3; i <= n; i++) {
for (int j = min(i, k); j >= 1; j--) {
dp[i] = min(dp[i], dp[i - j] + abs(a[i] - a[i - j]));
}
}
cout << dp[n];
return 0;
}
| #include <bits/stdc++.h>
#define el_cucuy \
ios_base::sync_with_stdio(0), cout.tie(0); \
cin.tie(0);
#define llong long long
#define pb push_back
#define bpc __builtin_popcount
const llong mxn = 1e6 + 7;
const llong mod = 1e9 + 7;
const llong inf = 1e18 + 9;
using namespace std;
llong n, k, a[mxn], dp[mxn];
int main() {
el_cucuy cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
dp[1] = 0;
dp[2] = abs(a[1] - a[2]);
for (int i = 3; i <= n; i++)
dp[i] = inf;
for (llong i = 3; i <= n; i++) {
for (int j = min(i - 1, k); j >= 1; j--) {
dp[i] = min(dp[i], dp[i - j] + abs(a[i] - a[i - j]));
}
}
cout << dp[n];
return 0;
}
| [
"control_flow.loop.for.initializer.change"
] | 959,895 | 959,896 | u122292453 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> vec(n);
for (int i = 0; i < n; i++)
cin >> vec[i];
int dp[n + 1];
for (int i = 0; i <= n; i++)
dp[i] = INT_MAX;
dp[0] = 0;
dp[1] = 0;
for (int j = 2; j <= n; j++) {
for (int i = 1; i <= k; i++)
if (j >= i)
dp[j] = min(dp[j - i] + abs(vec[j - 1] - vec[j - i - 1]), dp[j]);
// else dp[j]=dp[j-1]+abs(vec[j-1]-vec[j-2]);
}
cout << dp[n] % INT_MAX << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> vec(n);
for (int i = 0; i < n; i++)
cin >> vec[i];
int dp[n + 1];
for (int i = 0; i <= n; i++)
dp[i] = INT_MAX;
dp[0] = 0;
dp[1] = 0;
for (int j = 2; j <= n; j++) {
for (int i = 1; i <= k; i++)
if (j > i)
dp[j] = min(dp[j - i] + abs(vec[j - 1] - vec[j - i - 1]), dp[j]);
// else dp[j]=dp[j-1]+abs(vec[j-1]-vec[j-2]);
}
cout << dp[n] % INT_MAX << endl;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 959,900 | 959,901 | u694116078 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> vec(n);
for (int i = 0; i < n; i++)
cin >> vec[i];
int dp[n + 1];
for (int i = 0; i <= n; i++)
dp[i] = INT_MAX;
dp[0] = 0;
dp[1] = 0;
for (int j = 2; j <= n; j++) {
for (int i = 1; i <= k; i++)
if (j >= i)
dp[j] = min(dp[j - i] + abs(vec[j - 1] - vec[j - i - 1]), dp[j]);
// else dp[j]=dp[j-1]+abs(vec[j-1]-vec[j-2]);
}
cout << dp[n] << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> vec(n);
for (int i = 0; i < n; i++)
cin >> vec[i];
int dp[n + 1];
for (int i = 0; i <= n; i++)
dp[i] = INT_MAX;
dp[0] = 0;
dp[1] = 0;
for (int j = 2; j <= n; j++) {
for (int i = 1; i <= k; i++)
if (j > i)
dp[j] = min(dp[j - i] + abs(vec[j - 1] - vec[j - i - 1]), dp[j]);
// else dp[j]=dp[j-1]+abs(vec[j-1]-vec[j-2]);
}
cout << dp[n] % INT_MAX << endl;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 959,902 | 959,901 | u694116078 | cpp |
p03161 | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <map>
#include <math.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int n, k;
cin >> n >> k;
vector<int> h(n);
for (int i = 0; i < n; i++) {
cin >> h[i];
}
vector<ll> dp(n);
dp[0] = 0;
for (int i = 0; i < n - 1; i++) {
ll x = pow(10, 9);
for (int j = 0; j < min(i + 1, k) + 1; j++) {
if (dp[i + 1 - j] + abs(h[i + 1] - h[i + 1 - j]) < x) {
x = dp[i + 1 - j] + abs(h[i + 1] - h[i + 1 - j]);
}
}
dp[i + 1] = x;
}
cout << dp[n - 1];
} | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <map>
#include <math.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int n, k;
cin >> n >> k;
vector<int> h(n);
for (int i = 0; i < n; i++) {
cin >> h[i];
}
vector<ll> dp(n);
dp[0] = 0;
for (int i = 0; i < n - 1; i++) {
ll x = pow(10, 9);
for (int j = 1; j < min(i + 1, k) + 1; j++) {
if (dp[i + 1 - j] + abs(h[i + 1] - h[i + 1 - j]) < x) {
x = dp[i + 1 - j] + abs(h[i + 1] - h[i + 1 - j]);
}
}
dp[i + 1] = x;
}
cout << dp[n - 1];
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 959,907 | 959,908 | u340010271 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
long long cost[100005];
long long dp[100005];
int main() {
ios::sync_with_stdio(0);
cin.tie();
int N, a, k;
cin >> N >> k;
for (int i = 0; i < N + 1; i++)
dp[i] = 100009; // set value
for (int i = 0; i < N; i++) {
cin >> a;
cost[i] = a;
}
dp[0] = 0;
for (int i = 1; i < N; i++) {
for (int j = 1; j < k + 1; j++) {
if (i - j >= 0)
dp[i] = min(dp[i], dp[i - j] + abs(cost[i] - cost[i - j]));
else {
break;
}
}
}
cout << dp[N - 1];
}
| #include <bits/stdc++.h>
using namespace std;
int cost[100005];
int dp[100005];
int main() {
ios::sync_with_stdio(0);
cin.tie();
int N, a, k;
cin >> N >> k;
for (int i = 0; i < N + 1; i++)
dp[i] = 1000000002; // set value
for (int i = 0; i < N; i++) {
cin >> a;
cost[i] = a;
}
dp[0] = 0;
for (int i = 1; i < N; i++) {
for (int j = 1; j < k + 1; j++) {
if (i - j >= 0)
dp[i] = min(dp[i], dp[i - j] + abs(cost[i] - cost[i - j]));
else {
break;
}
}
}
cout << dp[N - 1];
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.narrow.change",
"literal.number.change",
"assignment.value.change"
] | 959,917 | 959,918 | u507814996 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
int cost[100005];
int dp[100005];
int main() {
ios::sync_with_stdio(0);
cin.tie();
int N, a, k;
cin >> N >> k;
for (int i = 0; i < N + 1; i++)
dp[i] = 100009; // set value
for (int i = 0; i < N; i++) {
cin >> a;
cost[i] = a;
}
dp[0] = 0;
for (int i = 1; i < N; i++) {
for (int j = 1; j < k + 1; j++) {
if (i - j >= 0)
dp[i] = min(dp[i], dp[i - j] + abs(cost[i] - cost[i - j]));
else {
break;
}
}
}
cout << dp[N - 1];
} | #include <bits/stdc++.h>
using namespace std;
int cost[100005];
int dp[100005];
int main() {
ios::sync_with_stdio(0);
cin.tie();
int N, a, k;
cin >> N >> k;
for (int i = 0; i < N + 1; i++)
dp[i] = 1000000002; // set value
for (int i = 0; i < N; i++) {
cin >> a;
cost[i] = a;
}
dp[0] = 0;
for (int i = 1; i < N; i++) {
for (int j = 1; j < k + 1; j++) {
if (i - j >= 0)
dp[i] = min(dp[i], dp[i - j] + abs(cost[i] - cost[i - j]));
else {
break;
}
}
}
cout << dp[N - 1];
}
| [
"literal.number.change",
"assignment.value.change"
] | 959,919 | 959,918 | u507814996 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
typedef long long i64;
int main() {
int n, k;
cin >> n >> k;
i64 a[n], dp[n + 1];
for (int i = 0; i <= n; i++)
dp[i] = 100000;
for (int i = 0; i < n; i++)
cin >> a[i];
dp[0] = 0;
dp[1] = abs(a[1] - a[0]);
for (int i = 2; i < n; i++) {
for (int j = 1; j <= k; j++) {
if (i >= j) {
dp[i] = min(dp[i], dp[i - j] + abs(a[i] - a[i - j]));
}
}
}
cout << dp[n - 1] << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long i64;
int main() {
int n, k;
cin >> n >> k;
i64 a[n], dp[n + 1];
for (int i = 0; i <= n; i++)
dp[i] = INT_MAX;
for (int i = 0; i < n; i++)
cin >> a[i];
dp[0] = 0;
dp[1] = abs(a[1] - a[0]);
for (int i = 2; i < n; i++) {
for (int j = 1; j <= k; j++) {
if (i >= j) {
dp[i] = min(dp[i], dp[i - j] + abs(a[i] - a[i - j]));
}
}
}
cout << dp[n - 1] << endl;
} | [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 959,923 | 959,924 | u644295564 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
int min_cost(int *arr, int n, int k) {
int *dp = new int[n + 1];
dp[0] = 0;
dp[1] = 0;
dp[2] = abs(arr[1] - arr[2]);
for (int i = 3; i <= n; ++i) {
int temp = INT_MAX;
for (int j = 1; j <= k && (i - j) >= 0; ++j) {
temp = min(temp, abs(arr[i] - arr[i - j]) + dp[i - j]);
}
dp[i] = temp;
}
int ans = dp[n];
delete[] dp;
return ans;
}
int main() {
int n, k;
cin >> n >> k;
int arr[n + 1];
arr[0] = 0;
for (int i = 1; i <= n; ++i) {
cin >> arr[i];
}
cout << min_cost(arr, n, k);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int min_cost(int *arr, int n, int k) {
int *dp = new int[n + 1];
dp[0] = 0;
dp[1] = 0;
dp[2] = abs(arr[1] - arr[2]);
for (int i = 3; i <= n; ++i) {
int temp = INT_MAX;
for (int j = 1; j <= k && (i - j) > 0; ++j) {
temp = min(temp, abs(arr[i] - arr[i - j]) + dp[i - j]);
}
dp[i] = temp;
}
int ans = dp[n];
delete[] dp;
return ans;
}
int main() {
int n, k;
cin >> n >> k;
int arr[n + 1];
arr[0] = 0;
for (int i = 1; i <= n; ++i) {
cin >> arr[i];
}
cout << min_cost(arr, n, k);
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 959,925 | 959,926 | u169602617 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define flp(i, a, b) for (int i = a; i < b; i++)
#define ios \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define blp(i, a, b) for (int i = a; i >= b; i--)
#define lol 1000000007
ll fact[100001];
void init() {
fact[0] = 1;
for (ll i = 1; i < 100001; i++) {
fact[i] = (i * fact[i - 1]) % lol;
}
}
long long binpow(long long a, long long b, long long m) {
a %= m;
long long res = 1;
while (b > 0) {
if (b & 1)
res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
ll modInverse(ll n, ll p) { return binpow(n, p - 2, p); }
ll solve(ll n, ll r, ll p) {
if (r == 0)
return 1;
return (fact[n] *
((modInverse(fact[r], p) * modInverse(fact[n - r], p)) % p)) %
p;
}
int main() {
ios;
ll n, k;
cin >> n >> k;
int a[n];
flp(i, 0, n) { cin >> a[i]; }
int dp[n];
dp[0] = 0;
flp(i, 1, n) {
dp[i] = dp[i - 1] + abs(a[i] - a[i - 1]);
for (int j = 2; j <= k; j++) {
if (i >= k) {
dp[i] = min(dp[i], dp[i - j] + abs(a[i] - a[i - j]));
}
}
}
cout << dp[n - 1] << "\n";
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define flp(i, a, b) for (int i = a; i < b; i++)
#define ios \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define blp(i, a, b) for (int i = a; i >= b; i--)
#define lol 1000000007
ll fact[100001];
void init() {
fact[0] = 1;
for (ll i = 1; i < 100001; i++) {
fact[i] = (i * fact[i - 1]) % lol;
}
}
long long binpow(long long a, long long b, long long m) {
a %= m;
long long res = 1;
while (b > 0) {
if (b & 1)
res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
ll modInverse(ll n, ll p) { return binpow(n, p - 2, p); }
ll solve(ll n, ll r, ll p) {
if (r == 0)
return 1;
return (fact[n] *
((modInverse(fact[r], p) * modInverse(fact[n - r], p)) % p)) %
p;
}
int main() {
ios;
ll n, k;
cin >> n >> k;
int a[n];
flp(i, 0, n) { cin >> a[i]; }
int dp[n];
dp[0] = 0;
flp(i, 1, n) {
dp[i] = dp[i - 1] + abs(a[i] - a[i - 1]);
for (int j = 2; j <= k; j++) {
if (i >= j) {
dp[i] = min(dp[i], dp[i - j] + abs(a[i] - a[i - j]));
}
}
}
cout << dp[n - 1] << "\n";
} | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 959,931 | 959,932 | u667598788 | cpp |
p03161 | #include <iostream>
#include <math.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int arr[n], dp[n + 1] = {0};
for (int i = 0; i < n; ++i)
cin >> arr[i];
dp[0] = 0;
dp[1] = abs(arr[1] - arr[0]);
for (int i = 2; i < n; ++i) {
dp[i] = 2e9;
for (int j = 1; j <= min(i, k); ++j) {
dp[i] = min(dp[i - j] + abs(arr[i] - arr[i - j]), dp[i]);
}
}
cout << dp[n] << endl;
return 0;
} | #include <iostream>
#include <math.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int arr[n], dp[n + 1] = {0};
for (int i = 0; i < n; ++i)
cin >> arr[i];
dp[0] = 0;
dp[1] = abs(arr[1] - arr[0]);
for (int i = 2; i < n; ++i) {
dp[i] = 2e9;
for (int j = 1; j <= min(i, k); ++j) {
dp[i] = min(dp[i - j] + abs(arr[i] - arr[i - j]), dp[i]);
}
}
cout << dp[n - 1] << endl;
return 0;
} | [
"expression.operation.binary.add"
] | 959,933 | 959,934 | u774724188 | cpp |
p03161 | #include <iostream>
#include <math.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int arr[n], dp[n + 1] = {0};
for (int i = 0; i < n; ++i)
cin >> arr[i];
dp[0] = 0;
dp[1] = abs(arr[1] - arr[0]);
for (int i = 2; i < n; ++i) {
dp[i] = 2e9;
for (int j = 1; j < min(i, k); ++j) {
dp[i] = min(dp[i - j] + abs(arr[i] - arr[i - j]), dp[i]);
}
}
cout << dp[n] << endl;
return 0;
} | #include <iostream>
#include <math.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int arr[n], dp[n + 1] = {0};
for (int i = 0; i < n; ++i)
cin >> arr[i];
dp[0] = 0;
dp[1] = abs(arr[1] - arr[0]);
for (int i = 2; i < n; ++i) {
dp[i] = 2e9;
for (int j = 1; j <= min(i, k); ++j) {
dp[i] = min(dp[i - j] + abs(arr[i] - arr[i - j]), dp[i]);
}
}
cout << dp[n - 1] << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 959,935 | 959,934 | u774724188 | cpp |
p03161 | #include <algorithm>
#include <assert.h>
#include <bits/stdc++.h>
#include <bitset>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <vector>
using namespace std;
typedef long long ll;
constexpr long long int INFLL = 1001001001001001LL;
constexpr int INF = 1000000007;
const int mod = 1000000007;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
ll dp[100050];
int main() {
memset(dp, 0, sizeof(dp));
int N, K;
cin >> N >> K;
vector<int> h(N + 1);
for (int i = 1; i <= N; i++) {
cin >> h[i];
}
for (int i = 2; i <= N; i++) {
for (int k = 1; k <= K; k++) {
if (i - k < 0) {
break;
}
if (k == 1) {
dp[i] = dp[i - 1] + abs(h[i] - h[i - 1]);
} else {
dp[i] = min(dp[i], dp[i - k] + abs(h[i] - h[i - k]));
}
}
}
cout << dp[N] << endl;
return 0;
}
| #include <algorithm>
#include <assert.h>
#include <bits/stdc++.h>
#include <bitset>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <vector>
using namespace std;
typedef long long ll;
constexpr long long int INFLL = 1001001001001001LL;
constexpr int INF = 1000000007;
const int mod = 1000000007;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
ll dp[100050];
int main() {
memset(dp, 0, sizeof(dp));
int N, K;
cin >> N >> K;
vector<int> h(N + 1);
for (int i = 1; i <= N; i++) {
cin >> h[i];
}
for (int i = 2; i <= N; i++) {
for (int k = 1; k <= K; k++) {
if (i - k <= 0) {
break;
}
if (k == 1) {
dp[i] = dp[i - 1] + abs(h[i] - h[i - 1]);
} else {
dp[i] = min(dp[i], dp[i - k] + abs(h[i] - h[i - k]));
}
}
}
cout << dp[N] << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 959,936 | 959,937 | u550014122 | cpp |
p03161 | #include <algorithm>
#include <assert.h>
#include <bits/stdc++.h>
#include <bitset>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <vector>
using namespace std;
typedef long long ll;
constexpr long long int INFLL = 1001001001001001LL;
constexpr int INF = 1000000007;
const int mod = 1000000007;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
ll dp[100050];
int main() {
memset(dp, 0, sizeof(dp));
int N, K;
cin >> N >> K;
vector<int> h(N + 1);
for (int i = 1; i <= N; i++) {
cin >> h[i];
}
for (int i = 2; i <= N; i++) {
for (int k = 1; k <= K; k++) {
if (i - k < 0) {
break;
}
if (k == 1) {
dp[i] = dp[i - 1] + abs(h[i] - h[i - 1]);
}
dp[i] = min(dp[i], dp[i - k] + abs(h[i] - h[i - k]));
}
}
cout << dp[N] << endl;
return 0;
}
| #include <algorithm>
#include <assert.h>
#include <bits/stdc++.h>
#include <bitset>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <vector>
using namespace std;
typedef long long ll;
constexpr long long int INFLL = 1001001001001001LL;
constexpr int INF = 1000000007;
const int mod = 1000000007;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
ll dp[100050];
int main() {
memset(dp, 0, sizeof(dp));
int N, K;
cin >> N >> K;
vector<int> h(N + 1);
for (int i = 1; i <= N; i++) {
cin >> h[i];
}
for (int i = 2; i <= N; i++) {
for (int k = 1; k <= K; k++) {
if (i - k <= 0) {
break;
}
if (k == 1) {
dp[i] = dp[i - 1] + abs(h[i] - h[i - 1]);
} else {
dp[i] = min(dp[i], dp[i - k] + abs(h[i] - h[i - k]));
}
}
}
cout << dp[N] << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"control_flow.branch.else.add"
] | 959,938 | 959,937 | u550014122 | cpp |
p03161 | #include <algorithm>
#include <bits/stdc++.h>
using namespace std;
int main() {
int minimum;
int n, k;
cin >> n >> k;
if (k >= n)
k = n - 1;
int h[n];
int ans[n];
for (int i = 0; i < n; i++) {
cin >> h[i];
}
ans[0] = 0;
for (int i = 1; i < k; i++) {
ans[i] = abs(h[0] - h[i]);
}
for (int i = k; i < n; i++) {
ans[i] = 10000;
for (int j = 1; j <= k; j++) {
ans[i] = min(ans[i - j] + abs(h[i] - h[i - j]), ans[i]);
}
}
cout << ans[n - 1];
} | #include <algorithm>
#include <bits/stdc++.h>
using namespace std;
int main() {
int minimum;
long int n, k;
cin >> n >> k;
if (k >= n)
k = n - 1;
int h[n];
int ans[n];
for (int i = 0; i < n; i++) {
cin >> h[i];
}
ans[0] = 0;
for (int i = 1; i < k; i++) {
ans[i] = abs(h[0] - h[i]);
}
for (int i = k; i < n; i++) {
ans[i] = INT_MAX;
for (int j = 1; j <= k; j++) {
ans[i] = min(ans[i - j] + abs(h[i] - h[i - j]), ans[i]);
}
}
cout << ans[n - 1];
} | [
"variable_declaration.type.widen.change",
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 959,948 | 959,949 | u489264263 | cpp |
p03161 | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int N, K;
int h[100001];
long long dp[100001];
long long INF = 1LL << 60;
cin >> N >> K;
for (int i = 1; i <= N; i++) {
cin >> h[i];
}
dp[1] = 0;
dp[2] = abs(h[1] - h[2]);
for (int i = 3; i <= N; i++) {
long long min_cost = INF;
for (int j = 1; j <= K; j++) {
if (i - j == 0) {
continue;
}
long long cost = dp[i - j] + abs(h[i - j] - h[i]);
min_cost = min(cost, min_cost);
}
dp[i] = min_cost;
}
cout << dp[N] << endl;
return 0;
} | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int N, K;
int h[100001];
long long dp[100001];
long long INF = 1LL << 60;
cin >> N >> K;
for (int i = 1; i <= N; i++) {
cin >> h[i];
}
dp[1] = 0;
dp[2] = abs(h[1] - h[2]);
// ループごとにdp[i]を計算
for (int i = 3; i <= N; i++) {
long long min_cost = INF;
// j = ジャンプの距離
for (int j = 1; j <= K; j++) {
// ジャンプの開始点は1以上
if (i - j < 1) {
continue;
}
long long cost = dp[i - j] + abs(h[i - j] - h[i]);
min_cost = min(cost, min_cost);
}
dp[i] = min_cost;
}
cout << dp[N] << endl;
return 0;
} | [
"control_flow.loop.for.condition.change"
] | 959,950 | 959,951 | u790272146 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, minn;
cin >> n >> k;
int dp[n], h[n];
dp[0] = 0;
for (int i = 0; i < n; i++) {
cin >> h[i];
}
for (int i = 1; i < n; i++) {
minn = 32767;
for (int j = 1; j <= k; j++) {
if (i - j >= 0) {
if (dp[i - j] + abs(h[i] - h[i - j]) < minn)
minn = dp[i - j] + abs(h[i] - h[i - j]);
} else
break;
}
dp[i] = minn;
}
cout << dp[n - 1];
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
long int minn;
cin >> n >> k;
int dp[n], h[n];
dp[0] = 0;
for (int i = 0; i < n; i++) {
cin >> h[i];
}
for (int i = 1; i < n; i++) {
minn = 2147483647;
for (int j = 1; j <= k; j++) {
if (i - j >= 0) {
if (dp[i - j] + abs(h[i] - h[i - j]) < minn)
minn = dp[i - j] + abs(h[i] - h[i - j]);
} else
break;
}
dp[i] = minn;
}
cout << dp[n - 1];
return 0;
} | [
"literal.number.change",
"assignment.value.change"
] | 959,954 | 959,953 | u421029744 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef pair<int, int> pii;
#define fastio() \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define pb push_back
#define F first
#define S second
// cout<<fixed<<setprecision(11);
const string nl = "\n";
const ll MOD = 1000000007;
const ll ARR_MAX = 1e5 + 1;
const ll INF = 1e10 + 1;
void solve() {
int n, k;
cin >> n >> k;
ll dp[n + 1]; // dp[i]=minimum cost required to reach rock i-1.
ll h[n + 1];
// h[0]=0;
for (int i = 0; i < n; i++) {
cin >> h[i];
dp[i + 1] = INF;
}
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= k && j < n; j++) {
dp[i + j] = min(dp[i + j], dp[i] + max(h[i + j] - h[i], h[i] - h[i + j]));
}
}
cout << dp[n - 1] << nl;
}
int main() {
int t = 1;
// cin>>t;
while (t--) {
solve();
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef pair<int, int> pii;
#define fastio() \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
#define pb push_back
#define F first
#define S second
// cout<<fixed<<setprecision(11);
const string nl = "\n";
const ll MOD = 1000000007;
const ll ARR_MAX = 1e5 + 1;
const ll INF = 1e10 + 1;
void solve() {
int n, k;
cin >> n >> k;
ll dp[n + 1]; // dp[i]=minimum cost required to reach rock i-1.
ll h[n + 1];
// h[0]=0;
for (int i = 0; i < n; i++) {
cin >> h[i];
dp[i + 1] = INF;
}
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= k && i + j < n; j++) {
dp[i + j] = min(dp[i + j], dp[i] + max(h[i + j] - h[i], h[i] - h[i + j]));
}
}
cout << dp[n - 1] << nl;
}
int main() {
int t = 1;
// cin>>t;
while (t--) {
solve();
}
return 0;
} | [
"control_flow.loop.for.condition.change"
] | 959,959 | 959,960 | u427236648 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define inf 100000000;
typedef long long ll;
int main() {
int n;
cin >> n;
int k;
cin >> k;
int h[n + 5];
rep(i, n) { cin >> h[i]; }
ll dp[n + 5];
for (int i = 0; i < n; i++) {
dp[i] = inf;
}
dp[0] = 0;
dp[1] = abs(h[0] - h[1]);
for (int i = 0; i < n; i++) {
for (int j = 1; j <= min(n - i - 1, k); j++) {
dp[i + j] = min(dp[i + k], dp[i] + abs(h[i] - h[i + k]));
}
}
cout << dp[n - 1] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define inf 10000000000000;
typedef long long ll;
int main() {
int n;
cin >> n;
int k;
cin >> k;
int h[n + 100];
rep(i, n) { cin >> h[i]; }
ll dp[n + 100];
for (int i = 0; i < n; i++) {
dp[i] = inf;
}
dp[0] = 0;
dp[1] = abs(h[0] - h[1]);
for (int i = 0; i < n; i++) {
for (int j = 1; j <= min(n - i - 1, k); j++) {
dp[i + j] = min(dp[i + j], dp[i] + abs(h[i] - h[i + j]));
}
}
cout << dp[n - 1] << endl;
return 0;
} | [
"preprocessor.define.value.change",
"literal.integer.change",
"literal.number.change",
"expression.operation.binary.change",
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change"
] | 959,964 | 959,962 | u950411977 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
long long INF = 1e18;
int main() {
int n, k;
cin >> n >> k;
int h[n + 100];
for (int i = 0; i < n; i++) {
cin >> h[i];
}
long long dp[100010];
for (int i = 0; i < 10000; i++)
dp[i] = INF;
dp[0] = 0;
dp[1] = abs(h[1] - h[0]);
for (int i = 0; i < n; i++) {
for (int j = 1; j <= min(n - 1 - 1, k); j++) {
dp[i + j] = min(dp[i + j], dp[i] + abs(h[i] - h[i + j]));
}
}
cout << dp[n - 1] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
long long INF = 1e18;
int main() {
int n, k;
cin >> n >> k;
int h[n + 100];
for (int i = 0; i < n; i++) {
cin >> h[i];
}
long long dp[100010];
for (int i = 0; i < 100010; i++)
dp[i] = INF;
dp[0] = 0;
dp[1] = abs(h[1] - h[0]);
for (int i = 0; i < n; i++) {
for (int j = 1; j <= min(n - i - 1, k); j++) {
dp[i + j] = min(dp[i + j], dp[i] + abs(h[i] - h[i + j]));
}
}
cout << dp[n - 1] << endl;
return 0;
} | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change"
] | 959,967 | 959,966 | u566900820 | cpp |
p03161 | /*
Templatka c++ Kacper Fis
//
*/
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000001;
const float PI = 3.14;
typedef long long LL;
typedef vector<int> vi;
typedef list<int> li;
typedef queue<int> qi;
typedef pair<int, int> ii;
typedef map<string, int> msi; // np msi['nazwa'] = 'liczba'
typedef vector<ii> vii; // vector par<int>, do tworzenia tablicy dla grafów
// wagowych #dijkstra #Bellman_Ford
typedef priority_queue<ii, vector<ii>, greater<ii>>
pq; // kolejka priorytetowa vectorów par(top()=min) #dijkstra
vector<ii>::iterator iter;
#define print_list(x) \
for (it = (x).begin(); it != (x).end(); it++) { \
cout << *it << " "; \
}
#define print_vector(x) \
for (it2 = (x).begin(); it2 != (x).end(); it2++) { \
cout << *it2 << " "; \
}
#define search_list(x) for (it = (x).begin(); it != (x).end(); it++)
#define search_vector(x) \
for (it2 = (x).begin(); it2 != (x).end(); it2++) \
;
#define pb(x) push_back(x)
#define pf(x) push_front(x)
#define mp(x, y) make_pair(x, y)
///////////////////////////////////////////////GLOBAL
///DEFINITIONS////////////////////////////////////////////////////////
int tab[100005];
int dp[100005];
///////////////////////////////////////////////////FUNCTIONS/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////MAIN////////////////////////////////////////////////////////////////
int main(int argc, char *argv[]) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> tab[i];
}
for (int i = 0; i < 100005; i++) {
dp[i] = INF;
}
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < i + k; j++) {
if (i + j < n) {
dp[i + j] = min(dp[i + j], dp[i] + abs(tab[i] - tab[i + j]));
}
}
}
cout << dp[n - 1] << endl;
return 0;
}
| /*
Templatka c++ Kacper Fis
//
*/
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000001;
const float PI = 3.14;
typedef long long LL;
typedef vector<int> vi;
typedef list<int> li;
typedef queue<int> qi;
typedef pair<int, int> ii;
typedef map<string, int> msi; // np msi['nazwa'] = 'liczba'
typedef vector<ii> vii; // vector par<int>, do tworzenia tablicy dla grafów
// wagowych #dijkstra #Bellman_Ford
typedef priority_queue<ii, vector<ii>, greater<ii>>
pq; // kolejka priorytetowa vectorów par(top()=min) #dijkstra
vector<ii>::iterator iter;
#define print_list(x) \
for (it = (x).begin(); it != (x).end(); it++) { \
cout << *it << " "; \
}
#define print_vector(x) \
for (it2 = (x).begin(); it2 != (x).end(); it2++) { \
cout << *it2 << " "; \
}
#define search_list(x) for (it = (x).begin(); it != (x).end(); it++)
#define search_vector(x) \
for (it2 = (x).begin(); it2 != (x).end(); it2++) \
;
#define pb(x) push_back(x)
#define pf(x) push_front(x)
#define mp(x, y) make_pair(x, y)
///////////////////////////////////////////////GLOBAL
///DEFINITIONS////////////////////////////////////////////////////////
int tab[100005];
int dp[100005];
///////////////////////////////////////////////////FUNCTIONS/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////MAIN////////////////////////////////////////////////////////////////
int main(int argc, char *argv[]) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> tab[i];
}
for (int i = 0; i < 100005; i++) {
dp[i] = INF;
}
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= k; j++) {
if (i + j < n) {
dp[i + j] = min(dp[i + j], dp[i] + abs(tab[i] - tab[i + j]));
}
}
}
cout << dp[n - 1] << endl;
return 0;
}
| [
"control_flow.loop.for.initializer.change",
"expression.operation.binary.remove",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 959,973 | 959,974 | u506295831 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
#define pb push_back
#define mp make_pair
#define rep(i, n) for (int i = 0; i < (n); ++i)
const int mod = 1000000007;
const int mod1 = 998244353;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
vector<int> a(n);
rep(i, n) cin >> a.at(i);
vector<int> dp(n + 2, 1000000000);
dp.at(0) = 0;
rep(i, n - 1) {
for (int j = 1; j < k && i + j < n; ++j) {
dp.at(i + j) = min(dp.at(i + j), dp.at(i) + abs(a.at(i) - a.at(i + j)));
}
}
cout << dp.at(n - 1) << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
#define pb push_back
#define mp make_pair
#define rep(i, n) for (int i = 0; i < (n); ++i)
const int mod = 1000000007;
const int mod1 = 998244353;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
vector<int> a(n);
rep(i, n) cin >> a.at(i);
vector<int> dp(n + 2, 1000000000);
dp.at(0) = 0;
rep(i, n - 1) {
for (int j = 1; j <= k && i + j < n; ++j) {
dp.at(i + j) = min(dp.at(i + j), dp.at(i) + abs(a.at(i) - a.at(i + j)));
}
}
cout << dp.at(n - 1) << endl;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 959,975 | 959,976 | u480831358 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
int h[100005], dp[100005];
int main() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> h[i];
}
memset(dp, 1e9, sizeof(dp));
dp[1] = 0;
for (int i = 2; i <= min(k, n); i++)
for (int j = 1; j < i; j++)
dp[i] = min(dp[i], abs(h[i] - h[j]) + dp[j]);
for (int i = k + 1; i <= n; i++)
for (int j = i - k; j < i; j++)
dp[i] = min(dp[i], abs(h[i] - h[j]) + dp[j]);
cout << dp[n];
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int h[100005], dp[100005];
int main() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> h[i];
}
memset(dp, 1234645198452, sizeof(dp));
dp[1] = 0;
for (int i = 2; i <= min(k, n); i++)
for (int j = 1; j < i; j++)
dp[i] = min(dp[i], abs(h[i] - h[j]) + dp[j]);
for (int i = k + 1; i <= n; i++)
for (int j = i - k; j < i; j++)
dp[i] = min(dp[i], abs(h[i] - h[j]) + dp[j]);
cout << dp[n];
return 0;
} | [
"literal.number.change",
"call.arguments.change"
] | 959,979 | 959,980 | u314693739 | cpp |
p03161 | #include <iostream>
using namespace std;
int DP[100100];
int H[100100];
int main() {
int N, K;
cin >> N >> K;
for (int i = 0; i < N; i++) {
cin >> H[i];
DP[i] = 999999999;
}
DP[0] = 0;
for (int i = 1; i < N; i++)
for (int j = i - 1; j >= 0 && i - j <= K; j--)
DP[i] = min(DP[i], DP[j] + abs(H[i] - H[j]));
cout << DP[N];
return 0;
} | #include <iostream>
using namespace std;
int DP[100100];
int H[100100];
int main() {
int N, K;
cin >> N >> K;
for (int i = 0; i < N; i++) {
cin >> H[i];
DP[i] = 999999999;
}
DP[0] = 0;
for (int i = 1; i < N; i++)
for (int j = i - 1; j >= 0 && i - j <= K; j--)
DP[i] = min(DP[i], DP[j] + abs(H[i] - H[j]));
cout << DP[N - 1];
return 0;
} | [
"expression.operation.binary.add"
] | 959,994 | 959,995 | u538921909 | cpp |
p03161 | #include <iostream>
using namespace std;
int DP[100100];
int H[100100];
int main() {
int N, K;
cin >> N >> K;
for (int i = 0; i < N; i++) {
cin >> H[i];
DP[i] = 999999999;
}
DP[0] = 0;
for (int i = 1; i < N; i++)
for (int j = i - 1; j >= 0 && i - j <= K; j--)
DP[i] = min(DP[i], DP[j] + abs(DP[i] - DP[j]));
cout << DP[N];
return 0;
} | #include <iostream>
using namespace std;
int DP[100100];
int H[100100];
int main() {
int N, K;
cin >> N >> K;
for (int i = 0; i < N; i++) {
cin >> H[i];
DP[i] = 999999999;
}
DP[0] = 0;
for (int i = 1; i < N; i++)
for (int j = i - 1; j >= 0 && i - j <= K; j--)
DP[i] = min(DP[i], DP[j] + abs(H[i] - H[j]));
cout << DP[N - 1];
return 0;
} | [
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 959,996 | 959,995 | u538921909 | cpp |
p03161 | #include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define mp make_pair
#define pii pair<ll, ll>
#define vi vector<ll>
#define vii vector<pii>
#define mi map<int, int>
#define mii map<pii, int>
#define all(a) (a).begin(), (a).end()
#define f1 first
#define f2 second
#define hell 10000007
#define in for (int i = a; i < b; i++)
using namespace std;
ll a[hell], b[hell];
ll dp[hell];
signed main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
ll i, j, k, l, test, n, c, sum = 0, sum1 = 0, sum2 = 0;
ll count = 0, count1 = 0, count2 = 0, val = 0, pos = 0, pos1 = 0;
bool flag = 1;
cin >> n >> k;
for (i = 1; i <= n; i++)
cin >> a[i];
dp[1] = 0;
dp[2] = abs(a[2] - a[1]);
for (i = 3; i <= n; i++) {
val = INT_MAX;
for (j = 1; j <= k; j++) {
if (i - j >= 0) {
if (dp[i - j] + abs(a[i - j] - a[i]) < val)
val = dp[i - j] + abs(a[i - j] - a[i]);
}
}
dp[i] = val;
}
cout << dp[n];
} | #include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define mp make_pair
#define pii pair<ll, ll>
#define vi vector<ll>
#define vii vector<pii>
#define mi map<int, int>
#define mii map<pii, int>
#define all(a) (a).begin(), (a).end()
#define f1 first
#define f2 second
#define hell 10000007
#define in for (int i = a; i < b; i++)
using namespace std;
ll a[hell], b[hell];
ll dp[hell];
signed main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
ll i, j, k, l, test, n, c, sum = 0, sum1 = 0, sum2 = 0;
ll count = 0, count1 = 0, count2 = 0, val = 0, pos = 0, pos1 = 0;
bool flag = 1;
cin >> n >> k;
for (i = 1; i <= n; i++)
cin >> a[i];
dp[1] = 0;
dp[2] = abs(a[2] - a[1]);
for (i = 3; i <= n; i++) {
val = INT_MAX;
for (j = 1; j <= k; j++) {
if (i - j >= 1) {
if (dp[i - j] + abs(a[i - j] - a[i]) < val)
val = dp[i - j] + abs(a[i - j] - a[i]);
}
}
dp[i] = val;
// if (val == INT_MAX) while (1);
}
cout << dp[n];
} | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 960,012 | 960,013 | u246947544 | cpp |
p03161 | #include <iostream>
#define lli long long int
using namespace std;
int main() {
lli n, k;
cin >> n >> k;
lli a[n + 1];
a[0] = 0;
for (lli i = 1; i <= n; i++)
cin >> a[i];
lli dp[n + 1] = {0};
dp[2] = abs(a[2] - a[1]);
lli m;
for (lli i = 3; i <= n; i++) {
m = 111111111111111;
for (lli j = k; j > 0; j--)
if (i - j >= 0)
m = min(m, dp[i - j] + abs(a[i] - a[i - j]));
dp[i] = m;
}
cout << dp[n];
return 0;
} | #include <iostream>
#define lli long long int
using namespace std;
int main() {
lli n, k;
cin >> n >> k;
lli a[n + 1];
a[0] = 0;
for (lli i = 1; i <= n; i++)
cin >> a[i];
lli dp[n + 1] = {0};
dp[2] = abs(a[2] - a[1]);
lli m;
for (lli i = 3; i <= n; i++) {
m = 111111111111111;
for (lli j = k; j > 0; j--)
if (i - j > 0)
m = min(m, dp[i - j] + abs(a[i] - a[i - j]));
dp[i] = m;
}
cout << dp[n];
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 960,014 | 960,015 | u882674169 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int(i) = 0; (i) < (n); i++)
using ll = long long;
const long long INF = 1LL << 60;
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;
}
int main() {
long long n, k;
cin >> n >> k;
long long h[n];
rep(i, n) cin >> h[i];
long long dp[n];
rep(i, n) dp[i] = INF;
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= k; j++) {
chmin(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;
#define rep(i, n) for (int(i) = 0; (i) < (n); i++)
using ll = long long;
const long long INF = 1LL << 60;
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;
}
int main() {
long long n, k;
cin >> n >> k;
long long h[110000];
rep(i, n) cin >> h[i];
long long dp[110000];
rep(i, 110000) dp[i] = INF;
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= k; j++) {
chmin(dp[i + j], abs(h[i] - h[i + j]) + dp[i]);
}
}
cout << dp[n - 1] << endl;
return 0;
}
| [
"identifier.replace.remove",
"literal.replace.add",
"variable_declaration.array_dimensions.change",
"assignment.variable.change",
"call.arguments.change"
] | 960,018 | 960,019 | u616053863 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
#define inf 1e5 + 10
#define LL long long
int main() {
LL n, k;
cin >> n >> k;
LL h[n];
for (LL i = 0; i < n; i++)
cin >> h[i];
LL dp[n + 1];
memset(dp, inf, sizeof(dp));
// dp[i] --> minimum cost incurred to reach i
for (LL i = 0; i <= n; i++) {
if (i == 0 || i == 1) {
dp[i] = 0;
continue;
}
for (LL j = 1; j <= k; j++) {
if (i > j) {
dp[i] = min(dp[i], dp[i - j] + abs(h[i - 1] - h[i - j - 1]));
}
}
}
cout << dp[n];
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define inf 1e4 + 10
#define LL long long
int main() {
LL n, k;
cin >> n >> k;
LL h[n];
for (LL i = 0; i < n; i++)
cin >> h[i];
LL dp[n + 1];
memset(dp, inf, sizeof(dp));
// dp[i] --> minimum cost incurred to reach i
for (LL i = 0; i <= n; i++) {
if (i == 0 || i == 1) {
dp[i] = 0;
continue;
}
for (LL j = 1; j <= k; j++) {
if (i > j) {
dp[i] = min(dp[i], dp[i - j] + llabs(h[i - 1] - h[i - j - 1]));
}
}
}
cout << dp[n];
return 0;
} | [
"preprocessor.define.value.change",
"literal.float.change",
"assignment.value.change",
"identifier.change",
"call.function.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 960,025 | 960,026 | u266864786 | cpp |
p03161 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define ALL(x) (x).begin(), (x).end()
#define RALL(x) (x).rbegin(), (x).rend()
#define DEBUG(x) cout << #x << " = " << (x) << endl;
#define SORT(x) sort(ALL(x));
#define RSORT(x) sort(RALL(x));
#define SUM(x) accumulate(ALL(x), 0);
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using pii = pair<int, int>;
using tiii = tuple<int, int, int>;
const int INF = 1e+9;
const ll mod = 1000000007;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
// cout << fixed << setprecision(10);
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int h[100010];
int dp[100010];
int main() {
int N, K;
cin >> N >> K;
rep(i, N) cin >> h[i];
rep(i, 100010) dp[i] = INF;
dp[0] = 0;
for (int n = 0; n < N; n++) {
for (int i = 1; n + i <= N; i++) {
dp[n + i] = min(dp[n + i], dp[n] + abs(h[n] - h[n + i]));
}
}
cout << dp[N - 1] << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define ALL(x) (x).begin(), (x).end()
#define RALL(x) (x).rbegin(), (x).rend()
#define DEBUG(x) cout << #x << " = " << (x) << endl;
#define SORT(x) sort(ALL(x));
#define RSORT(x) sort(RALL(x));
#define SUM(x) accumulate(ALL(x), 0);
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using pii = pair<int, int>;
using tiii = tuple<int, int, int>;
const int INF = 1e+9;
const ll mod = 1000000007;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
// cout << fixed << setprecision(10);
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int h[100010];
int dp[100010];
int main() {
int N, K;
cin >> N >> K;
rep(i, N) cin >> h[i];
rep(i, 100010) dp[i] = INF;
dp[0] = 0;
for (int n = 0; n < N; n++) {
for (int i = 1; i <= K; i++) {
dp[n + i] = min(dp[n + i], dp[n] + abs(h[n] - h[n + i]));
}
}
cout << dp[N - 1] << endl;
} | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove",
"identifier.change",
"expression.operation.binary.change"
] | 960,030 | 960,031 | u850516963 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int h[n + 1];
h[0] = 0;
for (int i = 1; i <= n; i++)
cin >> h[i];
int cost[n + 1];
for (int i = 0; i <= n; i++)
cost[i] = 100000;
cost[0] = 0;
cost[1] = 0;
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= k; j++) {
if (i - j >= 1)
cost[i] = min(cost[i], cost[i - j] + abs(h[i] - h[i - j]));
}
}
cout << cost[n];
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int h[n + 1];
h[0] = 0;
for (int i = 1; i <= n; i++)
cin >> h[i];
long long int cost[n + 1];
for (int i = 0; i <= n; i++)
cost[i] = 1000000000;
cost[0] = 0;
cost[1] = 0;
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= k; j++) {
if (i - j >= 1)
cost[i] = min(cost[i], cost[i - j] + abs(h[i] - h[i - j]));
}
}
cout << cost[n];
} | [
"literal.number.change",
"assignment.value.change"
] | 960,042 | 960,041 | u109133010 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
long long int h[n + 1], ans[n + 1];
for (int i = 1; i <= n; i++) {
cin >> h[i];
ans[i] = 200000;
}
ans[1] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= k; j++) {
if (j + i <= n)
ans[i + j] = min(ans[i + j], ans[i] + abs(h[i + j] - h[i]));
}
}
// for(int i=1;i<=n;i++){
// cout<<
// }
cout << ans[n];
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int h[n + 1], ans[n + 1];
for (int i = 1; i <= n; i++) {
cin >> h[i];
ans[i] = INT_MAX;
}
ans[1] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= k; j++) {
if (j + i <= n)
ans[i + j] = min(ans[i + j], ans[i] + abs(h[i + j] - h[i]));
}
}
// for(int i=1;i<=n;i++){
// cout<<
// }
cout << ans[n];
return 0;
} | [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 960,043 | 960,044 | u703327737 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
typedef long long int lli;
#define mod 1000000007
#define F first
#define S second
#define eb emplace_back
int main() {
// freopen("input.txt","r",stdin);
ios_base::sync_with_stdio(false);
cin.tie(0);
lli t, q, n, m, i, j, a, b, h, k;
cin >> n >> k;
lli ar[100001], cost[100001];
for (i = 1; i <= n; i++)
cin >> ar[i];
cost[1] = 0;
for (i = 2; i <= n; i++) {
cost[i] = INT_MAX;
for (j = i - 1; j >= i - k && j >= 0; j--)
cost[i] = min(cost[i], cost[j] + abs(ar[i] - ar[j]));
}
cout << cost[n];
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long int lli;
#define mod 1000000007
#define F first
#define S second
#define eb emplace_back
int main() {
// freopen("input.txt","r",stdin);
ios_base::sync_with_stdio(false);
cin.tie(0);
lli t, q, n, m, i, j, a, b, h, k;
cin >> n >> k;
lli ar[100001], cost[100001];
for (i = 1; i <= n; i++)
cin >> ar[i];
cost[1] = 0;
for (i = 2; i <= n; i++) {
cost[i] = INT_MAX;
for (j = i - 1; j >= i - k && j >= 1; j--)
cost[i] = min(cost[i], cost[j] + abs(ar[i] - ar[j]));
}
cout << cost[n];
return 0;
} | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 960,045 | 960,046 | u801195984 | cpp |
p03161 | #include <algorithm>
#include <iostream>
#include <vector>
int main() {
int n, k;
int infinite = 1000000000;
std::cin >> n >> k;
std::vector<int> stones{};
std::vector<int> dp{};
stones.resize(n);
dp.resize(n);
int h;
for (int i{}; i < n; i++) {
std::cin >> h;
stones[i] = h;
dp[i] = infinite;
}
dp[0] = 0;
for (int pos{}; pos < n; pos++) {
for (int m{1}; pos + m < n; m++) {
dp[pos + m] =
std::min(dp[pos + m], dp[pos] + abs(stones[pos] - stones[pos + m]));
}
}
std::cout << dp[n - 1];
}
| #include <algorithm>
#include <iostream>
#include <vector>
int main() {
int n, k;
int infinite = 1000000000;
std::cin >> n >> k;
std::vector<int> stones{};
std::vector<int> dp{};
stones.resize(n);
dp.resize(n);
int h;
for (int i{}; i < n; i++) {
std::cin >> h;
stones[i] = h;
dp[i] = infinite;
}
dp[0] = 0;
for (int pos{}; pos < n; pos++) {
for (int m{1}; pos + m < n && m <= k; m++) {
dp[pos + m] =
std::min(dp[pos + m], dp[pos] + abs(stones[pos] - stones[pos + m]));
}
}
std::cout << dp[n - 1];
} | [
"control_flow.loop.for.condition.change"
] | 960,065 | 960,066 | u252327607 | cpp |
p03161 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
#define pb push_back
#define fast_cin() \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int INF = 1e6 + 10, A = 5e3 + 10;
int main() {
fast_cin();
int n, k;
cin >> n;
cin >> k;
vector<int> h(n);
for (int i = 0; i < n; i++) {
cin >> h[i];
}
vector<int> dp(n, A);
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j <= k + i; j++) {
if (j < n) {
dp[j] = min(dp[j], dp[i] + abs(h[i] - h[j]));
}
}
}
cout << dp[n - 1];
}
| #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
#define pb push_back
#define fast_cin() \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int INF = 1e6 + 10, A = 5e3 + 10;
int main() {
fast_cin();
int n, k;
cin >> n;
cin >> k;
vector<int> h(n);
for (int i = 0; i < n; i++) {
cin >> h[i];
}
vector<int> dp(n, 2147483647);
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j <= k + i; j++) {
if (j < n) {
dp[j] = min(dp[j], dp[i] + abs(h[i] - h[j]));
}
}
}
cout << dp[n - 1];
}
| [] | 960,067 | 960,068 | u290208722 | cpp |
p03161 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
#define pb push_back
#define fast_cin() \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int INF = 1e6 + 10, A = 5e3 + 10;
int main() {
fast_cin();
int n, k;
cin >> n;
cin >> k;
vector<int> h(n);
for (int i = 0; i < n; i++) {
cin >> h[i];
}
vector<int> dp(n, 0);
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j <= k + i; j++) {
if (j < n) {
dp[j] = min(dp[j], dp[i] + abs(h[i] - h[j]));
}
}
}
cout << dp[n - 1];
}
| #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
#define pb push_back
#define fast_cin() \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int INF = 1e6 + 10, A = 5e3 + 10;
int main() {
fast_cin();
int n, k;
cin >> n;
cin >> k;
vector<int> h(n);
for (int i = 0; i < n; i++) {
cin >> h[i];
}
vector<int> dp(n, 2147483647);
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j <= k + i; j++) {
if (j < n) {
dp[j] = min(dp[j], dp[i] + abs(h[i] - h[j]));
}
}
}
cout << dp[n - 1];
}
| [
"literal.number.change",
"call.arguments.change"
] | 960,069 | 960,068 | u290208722 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
long long a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
long long dp[n + 1];
dp[0] = 0;
dp[1] = abs(a[1] - a[0]);
for (long int i = 2; i < n; i++) {
dp[i] = INT_MAX;
for (long int j = 1; j <= k; j++) {
if ((i - j) >= 0) {
dp[i] = min(dp[i], dp[i - j] + abs(a[i] + a[i - j]));
}
}
}
cout << dp[n - 1] << "\n";
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
long long a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
long long dp[n + 1];
dp[0] = 0;
dp[1] = abs(a[1] - a[0]);
for (long int i = 2; i < n; i++) {
dp[i] = INT_MAX;
for (long int j = 1; j <= k; j++) {
if ((i - j) >= 0) {
dp[i] = min(dp[i], dp[i - j] + abs(a[i] - a[i - j]));
}
}
}
cout << dp[n - 1] << "\n";
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 960,075 | 960,076 | u803405081 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int dp[n];
for (int i = 0; i < n; i++)
dp[i] = 10000000;
dp[0] = 0;
dp[1] = abs(arr[1] - arr[0]);
for (int i = 2; i < n; i++) {
for (int j = 1; j <= k; j++) {
if ((i - j) >= 0) {
dp[i] = min(dp[i], dp[i - k] + abs(arr[i] - arr[i - k]));
}
}
}
cout << dp[n - 1] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int dp[n];
for (int i = 0; i < n; i++)
dp[i] = 1000000008;
dp[0] = 0;
dp[1] = abs(arr[1] - arr[0]);
for (int i = 2; i < n; i++) {
for (int j = 1; j <= k; j++) {
if ((i - j) >= 0) {
dp[i] = min(dp[i], dp[i - j] + abs(arr[i] - arr[i - j]));
}
}
}
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",
"identifier.change"
] | 960,079 | 960,078 | u411604061 | cpp |
p03161 | #include "bits/stdc++.h"
#pragma GCC optimize("Ofast")
// Begin Header {{{
using namespace std;
#ifndef DEBUG
#define dump(...)
#endif
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define rep(i, n) for (intmax_t i = 0, i##_limit = (n); i < i##_limit; ++i)
#define reps(i, b, e) \
for (intmax_t i = (b), i##_limit = (e); i <= i##_limit; ++i)
#define repr(i, b, e) \
for (intmax_t i = (b), i##_limit = (e); i >= i##_limit; --i)
#define var(Type, ...) \
Type __VA_ARGS__; \
input(__VA_ARGS__)
constexpr size_t operator""_zu(unsigned long long value) { return value; };
constexpr intmax_t operator""_jd(unsigned long long value) { return value; };
constexpr uintmax_t operator""_ju(unsigned long long value) { return value; };
constexpr int INF = 0x3f3f3f3f;
constexpr intmax_t LINF = 0x3f3f3f3f3f3f3f3f_jd;
namespace moke {
template <class T> using MaxHeap = priority_queue<T, vector<T>, less<T>>;
template <class T> using MinHeap = priority_queue<T, vector<T>, greater<T>>;
inline void input() {}
template <class Head, class... Tail>
inline void input(Head &&head, Tail &&...tail) {
cin >> head;
input(forward<Tail>(tail)...);
}
template <class T> inline void input(vector<T> &vec) {
for (auto &e : vec) {
cin >> e;
}
}
template <class T> inline void input(vector<vector<T>> &mat) {
for (auto &vec : mat) {
input(vec);
}
}
inline void print() { cout << "\n"; }
template <class Head, class... Tail>
inline void print(Head &&head, Tail &&...tail) {
static constexpr const char *delim[] = {"", " "};
cout << head << delim[sizeof...(tail)];
print(forward<Tail>(tail)...);
}
template <class T>
inline ostream &operator<<(ostream &strm, const vector<T> &vec) {
static constexpr const char *delim[] = {" ", ""};
for (const auto &e : vec) {
strm << e << delim[&e == &vec.back()];
}
return strm;
}
template <class T> inline vector<T> make_v(const T &initValue, size_t sz) {
return vector<T>(sz, initValue);
}
template <class T, class... Args>
inline auto make_v(const T &initValue, size_t sz, Args... args) {
return vector<decltype(make_v<T>(initValue, args...))>(
sz, make_v<T>(initValue, args...));
}
template <class A, class B> inline bool chmax(A &a, const B &b) noexcept {
return b > a && (a = b, true);
}
template <class A, class B> inline bool chmin(A &a, const B &b) noexcept {
return b < a && (a = b, true);
}
template <class A, class B>
inline common_type_t<A, B> min(const A &a, const B &b) noexcept {
return a < b ? a : b;
}
template <class A, class B, class... Args>
inline common_type_t<A, B, Args...> min(const A &a, const B &b,
const Args &...args) noexcept {
return moke::min(a < b ? a : b, args...);
}
template <class A, class B>
inline common_type_t<A, B> max(const A &a, const B &b) noexcept {
return a > b ? a : b;
}
template <class A, class B, class... Args>
inline common_type_t<A, B, Args...> max(const A &a, const B &b,
const Args &...args) noexcept {
return moke::max(a > b ? a : b, args...);
}
template <class A, class B>
inline common_type_t<A, B> diff(const A &a, const B &b) noexcept {
return a < b ? b - a : a - b;
}
} // namespace moke
// }}} End Header
namespace moke {
size_t N, K;
vector<intmax_t> h;
vector<intmax_t> dp;
intmax_t rec(size_t idx) {
if (idx == 0)
return 0;
auto &ret = dp[idx];
if (~ret)
return ret;
ret = LINF;
reps(i, 1, K) {
if (idx - i >= 0) {
chmin(ret, rec(idx - i) + diff(h[idx], h[idx - i]));
}
}
return ret;
}
int main_() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
input(N, K);
h.resize(N);
input(h);
dp.resize(N, -1);
print(rec(N - 1));
return 0;
}
} // namespace moke
signed main() { // {{{
moke::main_();
return 0;
} // }}}
| #include "bits/stdc++.h"
#pragma GCC optimize("Ofast")
// Begin Header {{{
using namespace std;
#ifndef DEBUG
#define dump(...)
#endif
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define rep(i, n) for (intmax_t i = 0, i##_limit = (n); i < i##_limit; ++i)
#define reps(i, b, e) \
for (intmax_t i = (b), i##_limit = (e); i <= i##_limit; ++i)
#define repr(i, b, e) \
for (intmax_t i = (b), i##_limit = (e); i >= i##_limit; --i)
#define var(Type, ...) \
Type __VA_ARGS__; \
input(__VA_ARGS__)
constexpr size_t operator""_zu(unsigned long long value) { return value; };
constexpr intmax_t operator""_jd(unsigned long long value) { return value; };
constexpr uintmax_t operator""_ju(unsigned long long value) { return value; };
constexpr int INF = 0x3f3f3f3f;
constexpr intmax_t LINF = 0x3f3f3f3f3f3f3f3f_jd;
namespace moke {
template <class T> using MaxHeap = priority_queue<T, vector<T>, less<T>>;
template <class T> using MinHeap = priority_queue<T, vector<T>, greater<T>>;
inline void input() {}
template <class Head, class... Tail>
inline void input(Head &&head, Tail &&...tail) {
cin >> head;
input(forward<Tail>(tail)...);
}
template <class T> inline void input(vector<T> &vec) {
for (auto &e : vec) {
cin >> e;
}
}
template <class T> inline void input(vector<vector<T>> &mat) {
for (auto &vec : mat) {
input(vec);
}
}
inline void print() { cout << "\n"; }
template <class Head, class... Tail>
inline void print(Head &&head, Tail &&...tail) {
static constexpr const char *delim[] = {"", " "};
cout << head << delim[sizeof...(tail)];
print(forward<Tail>(tail)...);
}
template <class T>
inline ostream &operator<<(ostream &strm, const vector<T> &vec) {
static constexpr const char *delim[] = {" ", ""};
for (const auto &e : vec) {
strm << e << delim[&e == &vec.back()];
}
return strm;
}
template <class T> inline vector<T> make_v(const T &initValue, size_t sz) {
return vector<T>(sz, initValue);
}
template <class T, class... Args>
inline auto make_v(const T &initValue, size_t sz, Args... args) {
return vector<decltype(make_v<T>(initValue, args...))>(
sz, make_v<T>(initValue, args...));
}
template <class A, class B> inline bool chmax(A &a, const B &b) noexcept {
return b > a && (a = b, true);
}
template <class A, class B> inline bool chmin(A &a, const B &b) noexcept {
return b < a && (a = b, true);
}
template <class A, class B>
inline common_type_t<A, B> min(const A &a, const B &b) noexcept {
return a < b ? a : b;
}
template <class A, class B, class... Args>
inline common_type_t<A, B, Args...> min(const A &a, const B &b,
const Args &...args) noexcept {
return moke::min(a < b ? a : b, args...);
}
template <class A, class B>
inline common_type_t<A, B> max(const A &a, const B &b) noexcept {
return a > b ? a : b;
}
template <class A, class B, class... Args>
inline common_type_t<A, B, Args...> max(const A &a, const B &b,
const Args &...args) noexcept {
return moke::max(a > b ? a : b, args...);
}
template <class A, class B>
inline common_type_t<A, B> diff(const A &a, const B &b) noexcept {
return a < b ? b - a : a - b;
}
} // namespace moke
// }}} End Header
namespace moke {
size_t N, K;
vector<intmax_t> h;
vector<intmax_t> dp;
intmax_t rec(int idx) {
if (idx == 0)
return 0;
auto &ret = dp[idx];
if (~ret)
return ret;
ret = LINF;
reps(i, 1, K) {
if (idx - i >= 0) {
chmin(ret, rec(idx - i) + diff(h[idx], h[idx - i]));
}
}
return ret;
}
int main_() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
input(N, K);
h.resize(N);
input(h);
dp.resize(N, -1);
print(rec(N - 1));
return 0;
}
} // namespace moke
signed main() { // {{{
moke::main_();
return 0;
} // }}}
| [
"variable_declaration.type.primitive.change"
] | 960,082 | 960,083 | u671257784 | cpp |
p03161 | //<MIHIR KHAMBHATI/>
#include <bits/stdc++.h>
#include <chrono>
using namespace std::chrono;
using namespace std;
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
// // Declaring ordered_set
// typedef tree<ll, null_type, less<ll>, rb_tree_tag,
// tree_order_statistics_node_update>
// ordered_set;
#define _start_ auto __start__ = high_resolution_clock::now();
#define _stop_ \
cerr << "\n" \
<< duration_cast<microseconds>(high_resolution_clock::now() - \
__start__) \
.count() / \
(double)1000000 \
<< " sec\n";
#define mod 998244353
#define _ \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
#define deb(x) cerr << "\n" << #x << "=" << x << "\n";
#define deb2(x, y) \
cerr << "\n" << #x << "=" << x << "\n" << #y << "=" << y << "\n";
#define ideb \
int _p_; \
cin >> _p_;
typedef long long int ll;
typedef unsigned long long int ull;
long long power(long long x, long long n) {
long long result = 1;
while (n > 0) {
if (n % 2 == 1)
result = (result % mod * x % mod) % mod;
x = (x % mod * x % mod) % mod;
n = n / 2;
}
return result % mod;
}
int main() {
int n, k;
cin >> n >> k;
int a[n + 1];
for (int i = 1; i <= n; i++)
cin >> a[i];
int dp[n + 1];
for (int i = 0; i < n; i++)
dp[i] = INT_MAX;
dp[1] = 0;
dp[2] = abs(a[2] - a[1]);
for (int i = 3; i <= n; i++) {
for (int j = 1; j <= min(k, i - 1); j++) {
dp[i] = min(abs(a[i] - a[i - j]) + dp[i - j], dp[i]);
}
}
cout << dp[n];
} | //<MIHIR KHAMBHATI/>
#include <bits/stdc++.h>
#include <chrono>
using namespace std::chrono;
using namespace std;
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
// // Declaring ordered_set
// typedef tree<ll, null_type, less<ll>, rb_tree_tag,
// tree_order_statistics_node_update>
// ordered_set;
#define _start_ auto __start__ = high_resolution_clock::now();
#define _stop_ \
cerr << "\n" \
<< duration_cast<microseconds>(high_resolution_clock::now() - \
__start__) \
.count() / \
(double)1000000 \
<< " sec\n";
#define mod 998244353
#define _ \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
#define deb(x) cerr << "\n" << #x << "=" << x << "\n";
#define deb2(x, y) \
cerr << "\n" << #x << "=" << x << "\n" << #y << "=" << y << "\n";
#define ideb \
int _p_; \
cin >> _p_;
typedef long long int ll;
typedef unsigned long long int ull;
long long power(long long x, long long n) {
long long result = 1;
while (n > 0) {
if (n % 2 == 1)
result = (result % mod * x % mod) % mod;
x = (x % mod * x % mod) % mod;
n = n / 2;
}
return result % mod;
}
int main() {
int n, k;
cin >> n >> k;
int a[n + 1];
for (int i = 1; i <= n; i++)
cin >> a[i];
int dp[n + 1];
for (int i = 0; i <= n; i++)
dp[i] = INT_MAX;
dp[1] = 0;
dp[2] = abs(a[2] - a[1]);
for (int i = 3; i <= n; i++) {
for (int j = 1; j <= min(k, i - 1); j++) {
dp[i] = min(abs(a[i] - a[i - j]) + dp[i - j], dp[i]);
}
}
cout << dp[n];
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 960,092 | 960,093 | u213110772 | cpp |
p03161 | #include <bits/stdc++.h>
#define ll long long int
#define N 100000
#define f(i, a, b) for (ll i = (ll)a; i <= (ll)b; i++)
#define rf(i, a, b) for (ll i = (ll)a; i >= (ll)b; i--)
#define po pop_back
#define pb push_back
#define lb lower_bound
#define fi first
#define se second
#define debug(x) cout << #x << " = " << x << endl
#define ub upper_bound
#define ibs ios_base::sync_with_stdio(false)
#define cti cin.tie(0)
#define all(x) x.begin(), x.end()
#define PI 3.14159265
#define cot cout.tie(0)
using namespace std;
/**
* @author :: Sawlani
*
*/
int main() {
// freopen("input.txt","r",stdin);
ll n, k;
cin >> n >> k;
ll a[n + 1], dp[n + 1];
f(i, 1, n) cin >> a[i], dp[i] = LONG_MAX;
dp[1] = 0LL;
f(i, 2, n) {
rf(j, i - 1, max(0LL, i - k)) {
dp[i] = min(dp[i], abs(a[i] - a[j]) + dp[j]);
}
}
// f(i,1,n) cout << dp[i] << endl;
cout << dp[n];
}
| #include <bits/stdc++.h>
#define ll long long int
#define N 100000
#define f(i, a, b) for (ll i = (ll)a; i <= (ll)b; i++)
#define rf(i, a, b) for (ll i = (ll)a; i >= (ll)b; i--)
#define po pop_back
#define pb push_back
#define lb lower_bound
#define fi first
#define se second
#define debug(x) cout << #x << " = " << x << endl
#define ub upper_bound
#define ibs ios_base::sync_with_stdio(false)
#define cti cin.tie(0)
#define all(x) x.begin(), x.end()
#define PI 3.14159265
#define cot cout.tie(0)
using namespace std;
/**
* @author :: Sawlani
*
*/
int main() {
// freopen("input.txt","r",stdin);
ll n, k;
cin >> n >> k;
ll a[n + 1], dp[n + 1];
f(i, 1, n) cin >> a[i], dp[i] = LONG_MAX;
dp[1] = 0LL;
f(i, 2, n) {
rf(j, i - 1, max(1LL, i - k)) {
dp[i] = min(dp[i], abs(a[i] - a[j]) + dp[j]);
}
}
// f(i,1,n) cout << dp[i] << endl;
cout << dp[n];
}
| [
"literal.number.change",
"call.arguments.change"
] | 960,120 | 960,121 | u773105035 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[n], dp[n];
for (int i = 0; i < n; i++)
dp[i] = 1000000000;
for (int i = 0; i < n; i++)
cin >> a[i];
if (n > 2)
dp[0] = 0;
else {
cout << abs(a[1] - a[0]);
return 0;
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j <= i + k; i++) {
if (j < n)
dp[j] = min(dp[j], dp[i] + abs(a[j] - a[i]));
}
}
cout << dp[n - 1] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[n], dp[n];
for (int i = 0; i < n; i++)
dp[i] = 1000000000;
for (int i = 0; i < n; i++)
cin >> a[i];
if (n > 2)
dp[0] = 0;
else {
cout << abs(a[1] - a[0]);
return 0;
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j <= i + k; j++) {
if (j < n)
dp[j] = min(dp[j], dp[i] + abs(a[j] - a[i]));
}
}
cout << dp[n - 1] << endl;
return 0;
} | [
"identifier.change"
] | 960,126 | 960,127 | u703417608 | cpp |
p03161 | #include <algorithm>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <string>
using namespace std;
typedef long long ll;
const int maxn = 1e5 + 1111;
int arr[maxn];
int dp[maxn];
int main() {
int n, k;
scanf("%d%d", &n, &k);
dp[0] = dp[1] = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", arr + i);
dp[i] = dp[i - 1] + abs(arr[i] - arr[i - 1]);
for (int j = 2; j <= k && i - j > 0; ++j) {
dp[i] = min(dp[i - j] + abs(arr[i] - arr[i - j]), dp[i]);
}
}
printf("%d\n", dp[n]);
return 0;
} | #include <algorithm>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <string>
using namespace std;
typedef long long ll;
const int maxn = 1e5 + 1111;
int arr[maxn];
int dp[maxn];
int main() {
int n, k;
scanf("%d%d", &n, &k);
dp[0] = dp[1] = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", arr + i);
if (i > 1)
dp[i] = dp[i - 1] + abs(arr[i] - arr[i - 1]);
for (int j = 2; j <= k && i - j > 0; ++j) {
dp[i] = min(dp[i - j] + abs(arr[i] - arr[i - j]), dp[i]);
}
}
printf("%d\n", dp[n]);
return 0;
} | [
"control_flow.branch.if.add"
] | 960,133 | 960,134 | u997668091 | cpp |
p03161 | #include <algorithm>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <string>
using namespace std;
typedef long long ll;
const ll maxn = 1e6 + 1111;
int arr[maxn];
int dp[maxn];
int main() {
int n, k;
scanf("%d%d", &n, &k);
memset(dp, 0x3f3f3f, sizeof(dp));
arr[0] = 0x3f3f3f;
dp[0] = dp[0] = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", arr + i);
for (int j = 1; j <= k && i - j > 0; ++j) {
dp[i] = min(dp[i - j] + abs(arr[i] - arr[i - j]), dp[i]);
}
}
printf("%d\n", dp[n]);
return 0;
} | #include <algorithm>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <string>
using namespace std;
typedef long long ll;
const int maxn = 1e6 + 1111;
int arr[maxn];
int dp[maxn];
int main() {
int n, k;
scanf("%d%d", &n, &k);
memset(dp, 0x3f3f3f, sizeof(dp));
arr[0] = 0x3f3f3f;
dp[0] = dp[1] = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", arr + i);
for (int j = 1; j <= k && i - j > 0; ++j) {
dp[i] = min(dp[i - j] + abs(arr[i] - arr[i - j]), dp[i]);
}
}
printf("%d\n", dp[n]);
return 0;
} | [
"variable_declaration.type.change",
"literal.number.change",
"assignment.variable.change",
"variable_access.subscript.index.change"
] | 960,135 | 960,136 | u997668091 | cpp |
p03161 | #include <algorithm>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <string>
using namespace std;
typedef long long ll;
const ll maxn = 1e6 + 1111;
int arr[maxn];
int dp[maxn];
int main() {
int n, k;
scanf("%d%d", &n, &k);
memset(dp, 0x3f3f3f, sizeof(dp));
arr[0] = 0x3f3f3f;
dp[0] = dp[0] = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", arr + i);
if (i > 1)
for (int j = 1; j <= k && i - j > 0; ++j) {
dp[i] = min(dp[i - j] + abs(arr[i] - arr[i - j]), dp[i]);
}
}
printf("%d\n", dp[n]);
return 0;
} | #include <algorithm>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <string>
using namespace std;
typedef long long ll;
const int maxn = 1e6 + 1111;
int arr[maxn];
int dp[maxn];
int main() {
int n, k;
scanf("%d%d", &n, &k);
memset(dp, 0x3f3f3f, sizeof(dp));
arr[0] = 0x3f3f3f;
dp[0] = dp[1] = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", arr + i);
if (i > 1)
for (int j = 1; j <= k && i - j > 0; ++j) {
dp[i] = min(dp[i - j] + abs(arr[i] - arr[i - j]), dp[i]);
}
}
printf("%d\n", dp[n]);
return 0;
} | [
"variable_declaration.type.change",
"literal.number.change",
"assignment.variable.change",
"variable_access.subscript.index.change"
] | 960,137 | 960,138 | u997668091 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
int c = 0;
int main() {
int n, k;
cin >> n >> k;
int a[n], b[n], ans = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
b[i] = INT_MAX;
}
if (n == 1) {
cout << 0 << endl;
return 0;
}
b[0] = 0;
// b[1]=abs(a[1]-a[0]);
for (int i = 1; i < n; i++) {
int p = max(0, i - k);
for (int j = p; j < i; j++) {
b[i] = min(abs(a[j] - a[i]), b[i]);
}
}
cout << b[n - 1] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int c = 0;
int main() {
int n, k;
cin >> n >> k;
int a[n], b[n], ans = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
b[i] = INT_MAX;
}
if (n == 1) {
cout << 0 << endl;
return 0;
}
b[0] = 0;
// b[1]=abs(a[1]-a[0]);
for (int i = 1; i < n; i++) {
int p = max(0, i - k);
for (int j = p; j < i; j++) {
b[i] = min(abs(a[j] - a[i]) + b[j], b[i]);
}
}
cout << b[n - 1] << endl;
return 0;
}
| [
"assignment.change"
] | 960,139 | 960,140 | u372392968 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
int c = 0;
int main() {
int n, k;
cin >> n >> k;
int a[n], b[n], ans = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
b[i] = INT_MAX;
}
if (n == 1) {
cout << 0 << endl;
return 0;
}
b[0] = 0;
// b[1]=abs(a[1]-a[0]);
for (int i = 1; i < n; i++) {
int p = max(0, i - k);
for (int j = p; j < i; j++) {
b[i] = min(abs(a[p] - a[i]), b[i]);
}
}
cout << b[n - 1] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int c = 0;
int main() {
int n, k;
cin >> n >> k;
int a[n], b[n], ans = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
b[i] = INT_MAX;
}
if (n == 1) {
cout << 0 << endl;
return 0;
}
b[0] = 0;
// b[1]=abs(a[1]-a[0]);
for (int i = 1; i < n; i++) {
int p = max(0, i - k);
for (int j = p; j < i; j++) {
b[i] = min(abs(a[j] - a[i]) + b[j], b[i]);
}
}
cout << b[n - 1] << endl;
return 0;
}
| [
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change",
"assignment.change"
] | 960,141 | 960,140 | u372392968 | cpp |
p03161 | #include <bits/stdc++.h>
#define lint long long
#define INF 0x3f3f3f3f3f3f3f3f
using namespace std;
lint pd[100010];
int h[100010];
int n, k;
long long sapo2(int i) {
if (pd[i] != -1)
return pd[i];
if (i == n)
return pd[i] = 0;
pd[i] = INF;
for (int j = i + 1; j <= i + k && j <= n; j++) {
pd[i] = min(pd[i], abs(h[i] - h[i + 1]) + sapo2(j));
}
return pd[i];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> k;
for (int i = 1; i <= n; i++)
cin >> h[i];
memset(pd, -1, sizeof(pd));
cout << sapo2(1) << "\n";
return 0;
}
| #include <bits/stdc++.h>
#define lint long long
#define INF 0x3f3f3f3f3f3f3f3f
using namespace std;
lint pd[100010];
int h[100010];
int n, k;
long long sapo2(int i) {
if (pd[i] != -1)
return pd[i];
if (i == n)
return pd[i] = 0;
pd[i] = INF;
for (int j = i + 1; j <= i + k && j <= n; j++) {
pd[i] = min(pd[i], abs(h[i] - h[j]) + sapo2(j));
}
return pd[i];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> k;
for (int i = 1; i <= n; i++)
cin >> h[i];
memset(pd, -1, sizeof(pd));
cout << sapo2(1) << "\n";
return 0;
}
| [
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 960,147 | 960,148 | u810674239 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
int dp[1000001], N, k, h[1000000];
int main() {
int t;
cin >> N >> k;
for (int i = 0; i < N; i++) {
cin >> h[i];
}
dp[0] = 0, dp[1] = abs(h[0] - h[1]);
for (int i = 2; i < N; i++) {
dp[i] = dp[i - 1] + abs(h[i - 1] - h[i]);
for (int j = 1; j <= min(i - 1, k); j++) {
dp[i] = min(dp[i], dp[i - j] + abs(h[i - j] - h[i]));
}
}
cout << dp[N - 1] << "\n";
}
| #include <bits/stdc++.h>
using namespace std;
int dp[1000001], N, k, h[1000000];
int main() {
int t;
cin >> N >> k;
for (int i = 0; i < N; i++) {
cin >> h[i];
}
dp[0] = 0, dp[1] = abs(h[0] - h[1]);
for (int i = 2; i < N; i++) {
dp[i] = dp[i - 1] + abs(h[i - 1] - h[i]);
for (int j = 2; j <= min(i, k); j++) {
dp[i] = min(dp[i], dp[i - j] + abs(h[i - j] - h[i]));
// cout<<dp[i]<<" ";
}
// cout<<"\n";
}
cout << dp[N - 1] << "\n";
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 960,151 | 960,152 | u597808771 | cpp |
p03161 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
const int INF = 1e5 + 9;
int main() {
int n;
scanf("%d", &n);
int k;
scanf("%d", &k);
vector<int> v(n);
for (int &x : v)
scanf("%d", &x);
vector<int> dp(n, INF);
dp[0] = 0;
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j <= i + k; ++j) {
if (j < n)
dp[j] = min(dp[j], dp[i] + abs(v[i] - v[j]));
}
}
printf("%d\n", dp[n - 1]);
return 0;
} | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
const int INF = 1e9 + 5;
int main() {
int n;
scanf("%d", &n);
int k;
scanf("%d", &k);
vector<int> v(n);
for (int &x : v)
scanf("%d", &x);
vector<int> dp(n, INF);
dp[0] = 0;
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j <= i + k; ++j) {
if (j < n)
dp[j] = min(dp[j], dp[i] + abs(v[i] - v[j]));
}
}
printf("%d\n", dp[n - 1]);
return 0;
} | [
"literal.number.change",
"expression.operation.binary.change"
] | 960,155 | 960,156 | u753187241 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100;
int dp[maxn], arr[maxn];
int main() {
std::ios::sync_with_stdio(false);
int N, K;
cin >> N >> K;
for (int i = 1; i <= N; i++) {
cin >> arr[i];
dp[i] = 0x3f3f3f;
}
dp[0] = dp[1] = 0;
for (int k = 2; k <= N; k++)
for (int i = min(k, K); i > 0; i--)
dp[k] = min(dp[k], dp[k - i] + abs(arr[k] - arr[k - i]));
cout << dp[N] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100;
int dp[maxn], arr[maxn];
int main() {
std::ios::sync_with_stdio(false);
int N, K;
cin >> N >> K;
for (int i = 1; i <= N; i++) {
cin >> arr[i];
dp[i] = 0x3f3f3f3f;
}
dp[0] = dp[1] = 0;
for (int k = 2; k <= N; k++)
for (int i = min(k - 1, K); i > 0; i--)
dp[k] = min(dp[k], dp[k - i] + abs(arr[k] - arr[k - i]));
cout << dp[N] << endl;
return 0;
}
| [
"literal.number.change",
"assignment.value.change",
"control_flow.loop.for.initializer.change"
] | 960,157 | 960,158 | u716934273 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100;
int dp[maxn], arr[maxn];
int main() {
std::ios::sync_with_stdio(false);
int N, K;
cin >> N >> K;
for (int i = 1; i <= N; i++) {
cin >> arr[i];
dp[i] = 0x3f3f3f;
}
dp[0] = dp[1] = 0;
for (int k = 2; k <= N; k++)
for (int i = min(k, K); i > 0; i--)
dp[k] = min(dp[k], dp[k - i] + abs(arr[k] - arr[k - i]));
cout << dp[N] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100;
int dp[maxn], arr[maxn];
int main() {
std::ios::sync_with_stdio(false);
int N, K;
cin >> N >> K;
for (int i = 1; i <= N; i++) {
cin >> arr[i];
dp[i] = 0x3f3f3f3f;
}
dp[0] = dp[1] = 0;
for (int k = 2; k <= N; k++)
for (int i = min(k - 1, K); i > 0; i--)
dp[k] = min(dp[k], dp[k - i] + abs(arr[k] - arr[k - i]));
cout << dp[N] << endl;
return 0;
} | [
"literal.number.change",
"assignment.value.change",
"control_flow.loop.for.initializer.change"
] | 960,157 | 960,160 | u716934273 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n;
cin >> k;
if (n == 0 || k == 0) {
cout << 0;
return 0;
}
vector<int> h(n);
for (int i = 0; i < n; ++i)
cin >> h[i];
vector<int> F(n, 0);
for (int i = 1; i < n; ++i) {
int curr_min = INT_MAX;
for (int j = 1; j <= k; ++j) {
if (i - j >= 0) {
curr_min = min(curr_min, F[i - j] + abs(h[i] - h[i - j]));
}
}
F[i] = curr_min;
}
// for (auto e : F) cout << e << " "; cout << endl;
cout << (F[n - 1] != INT_MAX) ? F[n - 1] : 0;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n;
cin >> k;
if (n == 0 || k == 0) {
cout << 0;
return 0;
}
vector<int> h(n);
for (int i = 0; i < n; ++i)
cin >> h[i];
vector<int> F(n, 0);
for (int i = 1; i < n; ++i) {
int curr_min = INT_MAX;
for (int j = 1; j <= k; ++j) {
if (i - j >= 0) {
curr_min = min(curr_min, F[i - j] + abs(h[i] - h[i - j]));
}
}
F[i] = curr_min;
}
// for (auto e : F) cout << e << " "; cout << endl;
cout << (F[n - 1] != INT_MAX ? F[n - 1] : 0);
return 0;
} | [] | 960,165 | 960,166 | u002405247 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define de cout << "debuglandınız\n";
ll int N, i, j, K;
int main() {
// freopen("input.txt","r",stdin);
// freopen("output.txt","w",stdout);
cin >> N >> K;
vector<long long int> v(N), dp(N, 99999);
for (i = 0; i < N; i++)
cin >> v[i];
dp[0] = 0;
dp[1] = abs(v[1] - v[0]);
for (i = 0; i < N; i++) {
for (j = 1; j <= K; j++) {
if (i + j >= N)
break;
dp[i + j] = min(dp[i + j], dp[i] + abs(v[i] - v[i + j]));
}
}
cout << dp[N - 1];
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define de cout << "debuglandınız\n";
ll int N, i, j, K;
int main() {
// freopen("input.txt","r",stdin);
// freopen("output.txt","w",stdout);
cin >> N >> K;
vector<long long int> v(N), dp(N, 999999999);
for (i = 0; i < N; i++)
cin >> v[i];
dp[0] = 0;
dp[1] = abs(v[1] - v[0]);
for (i = 0; i < N; i++) {
for (j = 1; j <= K; j++) {
if (i + j >= N)
break;
dp[i + j] = min(dp[i + j], dp[i] + abs(v[i] - v[i + j]));
}
}
cout << dp[N - 1];
return 0;
} | [
"literal.number.change",
"call.arguments.change"
] | 960,179 | 960,180 | u207337956 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
#define MAX_N 100000
const int INF = 1e9;
int long dp[MAX_N];
int main() {
int n, k;
cin >> n >> k;
int step[n];
for (int i = 0; i < n; i++) {
cin >> step[i];
}
for (int i = 0; i < n; i++) {
dp[i] = INF;
}
dp[0] = 0;
for (int i = 2; i < n; i++) {
for (int K = 1; K <= k; K++) {
if (i - K < 0)
continue;
dp[i] = min(dp[i], dp[i - K] + abs(step[i] - step[i - K]));
}
}
cout << dp[n - 1] << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define MAX_N 100000
const int INF = 1e9;
int dp[MAX_N];
int main() {
int n, k;
cin >> n >> k;
int step[n];
for (int i = 0; i < n; i++) {
cin >> step[i];
}
for (int i = 0; i < n; i++) {
dp[i] = INF;
}
dp[0] = 0;
for (int i = 1; i < n; i++) {
for (int K = 1; K <= k; K++) {
if (i - K < 0)
continue;
dp[i] = min(dp[i], dp[i - K] + abs(step[i] - step[i - K]));
}
}
cout << dp[n - 1] << endl;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 960,181 | 960,182 | u158628538 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int *h = new int[n];
for (int i = 0; i < n; i++)
cin >> h[i];
int dp[n];
dp[n - 1] = 0;
dp[n - 2] = abs(h[n - 1] - h[n - 2]);
for (int i = n - 3; i >= 0; i--) {
int m = 2;
dp[i] = abs(h[i] - h[i + 1]) + dp[i + 1];
while (m <= k && i + k < n) {
int r = abs(h[i] - h[i + m]) + dp[i + m];
if (r < dp[i])
dp[i] = r;
m++;
}
}
cout << dp[0];
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int *h = new int[n];
for (int i = 0; i < n; i++)
cin >> h[i];
int dp[n];
dp[n - 1] = 0;
dp[n - 2] = abs(h[n - 1] - h[n - 2]);
for (int i = n - 3; i >= 0; i--) {
int m = 2;
dp[i] = abs(h[i] - h[i + 1]) + dp[i + 1];
while (m <= k && i + m < n) {
int r = abs(h[i] - h[i + m]) + dp[i + m];
if (r < dp[i])
dp[i] = r;
m++;
}
}
cout << dp[0];
return 0;
} | [
"identifier.change",
"control_flow.loop.condition.change"
] | 960,185 | 960,186 | u601256119 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int *h = new int[n];
for (int i = 0; i < n; i++)
cin >> h[i];
int dp[n];
dp[n - 1] = 0;
dp[n - 2] = abs(h[n - 1] - h[n - 2]);
for (int i = n - 3; i >= 0; i--) {
int m = 2;
dp[i] = abs(h[i] - h[i + 1]) + dp[i + 1];
while (m <= k && i + m < n) {
int r = abs(h[i] - h[i + k]) + dp[i + k];
if (r < dp[i])
dp[i] = r;
m++;
}
}
cout << dp[0];
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int *h = new int[n];
for (int i = 0; i < n; i++)
cin >> h[i];
int dp[n];
dp[n - 1] = 0;
dp[n - 2] = abs(h[n - 1] - h[n - 2]);
for (int i = n - 3; i >= 0; i--) {
int m = 2;
dp[i] = abs(h[i] - h[i + 1]) + dp[i + 1];
while (m <= k && i + m < n) {
int r = abs(h[i] - h[i + m]) + dp[i + m];
if (r < dp[i])
dp[i] = r;
m++;
}
}
cout << dp[0];
return 0;
} | [
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 960,187 | 960,186 | u601256119 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int *h = new int[n];
for (int i = 0; i < n; i++)
cin >> h[i];
int dp[n];
dp[n - 1] = 0;
dp[n - 2] = abs(h[n - 1] - h[n - 2]);
for (int i = n - 3; i >= 0; i--) {
int m = 2;
dp[i] = abs(h[i] - h[i + 1]) + dp[i + 1];
while (m <= k && i + k < n) {
int r = abs(h[i] - h[i + k]) + dp[i + k];
if (r < dp[i])
dp[i] = r;
m++;
}
}
cout << dp[0];
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int *h = new int[n];
for (int i = 0; i < n; i++)
cin >> h[i];
int dp[n];
dp[n - 1] = 0;
dp[n - 2] = abs(h[n - 1] - h[n - 2]);
for (int i = n - 3; i >= 0; i--) {
int m = 2;
dp[i] = abs(h[i] - h[i + 1]) + dp[i + 1];
while (m <= k && i + m < n) {
int r = abs(h[i] - h[i + m]) + dp[i + m];
if (r < dp[i])
dp[i] = r;
m++;
}
}
cout << dp[0];
return 0;
} | [
"identifier.change",
"control_flow.loop.condition.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 960,188 | 960,186 | u601256119 | cpp |
p03161 | // Nguyen Anh Tu
#include <bits/stdc++.h>
#define FOR(x, a, b) for (int x = a; x <= b; x++)
#define FORD(x, a, b) for (int x = a; x >= b; x--)
#define maxn 100005
#define maxc 1000000007
#define MOD 1000000007
#define reset(x, y) memset(x, y, sizeof(x))
#define task "frog"
#define mp make_pair
#define pb push_back
#define F first
#define S second
#define pii pair<int, int>
#define ll long long
#define bit(p, x) ((x >> p) & 1)
#define remain(a, b) (a + b >= MOD) ? (a + b - MOD) : (a + b)
using namespace std;
int n, a[maxn], k;
ll dp[maxn];
int main() {
// #ifndef ONLINE_JUDGE
ios_base::sync_with_stdio(NULL);
cin.tie(NULL);
cout.tie(NULL);
// freopen(task".inp","r",stdin);
// freopen(task".out","w",stdout);
// #endif
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
reset(dp, 110);
dp[1] = 0;
for (int i = 2; i <= n; ++i)
for (int j = 1; j <= k; ++j)
dp[i] = min(dp[i], dp[i - j] + abs(a[i] - a[i - j]));
cout << dp[n];
}
| // Nguyen Anh Tu
#include <bits/stdc++.h>
#define FOR(x, a, b) for (int x = a; x <= b; x++)
#define FORD(x, a, b) for (int x = a; x >= b; x--)
#define maxn 100005
#define maxc 1000000007
#define MOD 1000000007
#define reset(x, y) memset(x, y, sizeof(x))
#define task "frog"
#define mp make_pair
#define pb push_back
#define F first
#define S second
#define pii pair<int, int>
#define ll long long
#define bit(p, x) ((x >> p) & 1)
#define remain(a, b) (a + b >= MOD) ? (a + b - MOD) : (a + b)
using namespace std;
int n, a[maxn], k;
ll dp[maxn];
int main() {
// #ifndef ONLINE_JUDGE
ios_base::sync_with_stdio(NULL);
cin.tie(NULL);
cout.tie(NULL);
// freopen(task".inp","r",stdin);
// freopen(task".out","w",stdout);
// #endif
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
reset(dp, 110);
dp[1] = 0;
for (int i = 2; i <= n; ++i)
for (int j = 1; j <= min(i, k); ++j)
dp[i] = min(dp[i], dp[i - j] + abs(a[i] - a[i - j]));
cout << dp[n];
}
| [
"control_flow.loop.for.condition.change",
"call.add",
"call.arguments.change"
] | 960,191 | 960,192 | u522223354 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
const int maxx = 1e6 + 10;
const int INF = 1e4 + 10;
int in[maxx];
int dp[maxx];
int main() {
int n, k;
scanf("%d%d", &n, &k);
fill(dp, dp + n, INF);
for (int i = 0; i < n; i++) {
scanf("%d", &in[i]);
}
dp[0] = 0;
dp[1] = abs(in[0] - in[1]);
for (int j = 2; j < n; j++) {
for (int i = 1; i <= k; i++)
if (j - i >= 0)
dp[j] = min(dp[j], abs(in[j] - in[j - i]) + dp[j - i]);
}
printf("%d", dp[n - 1]);
} | #include <bits/stdc++.h>
using namespace std;
const int maxx = 1e6 + 10;
const int INF = 1e9 + 10;
int in[maxx];
int dp[maxx];
int main() {
int n, k;
scanf("%d%d", &n, &k);
fill(dp, dp + n, INF);
for (int i = 0; i < n; i++) {
scanf("%d", &in[i]);
}
dp[0] = 0;
dp[1] = abs(in[0] - in[1]);
for (int j = 2; j < n; j++) {
for (int i = 1; i <= k; i++)
if (j - i >= 0)
dp[j] = min(dp[j], abs(in[j] - in[j - i]) + dp[j - i]);
/*for(int j=0;j<n;j++)
printf("%d ",dp[j]);
printf("\n")*/
;
}
printf("%d", dp[n - 1]);
} | [
"literal.number.change",
"expression.operation.binary.change"
] | 960,193 | 960,194 | u530868041 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
#define int long long int
#define double long double
// 2 pointer approach interesting problem
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
cin >> n >> k;
int a[n + 1];
for (int i = 1; i <= n; i++)
cin >> a[i];
int dp[n + 1];
dp[1] = 0;
for (int i = 2; i <= n; i++) {
int mina = 1e18;
for (int j = i - 1; j >= (i - k); j--) {
if (j >= 0) {
int x = dp[j] + abs(a[i] - a[j]);
mina = min(mina, x);
}
}
dp[i] = mina;
}
cout << dp[n];
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long int
#define double long double
// 2 pointer approach interesting problem
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
cin >> n >> k;
int a[n + 1];
for (int i = 1; i <= n; i++)
cin >> a[i];
int dp[n + 1];
dp[1] = 0;
for (int i = 2; i <= n; i++) {
int mina = 1e18;
for (int j = i - 1; j >= (i - k); j--) {
if (j >= 1) {
int x = dp[j] + abs(a[i] - a[j]);
mina = min(mina, x);
}
}
dp[i] = mina;
}
cout << dp[n];
return 0;
} | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 960,201 | 960,202 | u598688088 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i, m, n) for (int i = m; i < n; i++)
#define SORT(v) sort(all(v))
#define INF 1000000007
#define fcout cout << fixed << setprecision(15)
typedef long long ll;
typedef pair<int, int> P;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; };
int lcm(int a, int b) { return a * b / gcd(a, b); };
int mod(int a, int b) { return (a + b - 1) / b; };
int month[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
};
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
int h[n];
rep(i, n) cin >> h[i];
ll dp[n];
fill(dp, dp + n, INF);
dp[0] = 0;
rep(i, n) {
REP(j, 1, k + 1) {
dp[i + j] = min(dp[i + j], (dp[i] + abs(h[i] - h[i + j])));
}
}
cout << dp[n - 1] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i, m, n) for (int i = m; i < n; i++)
#define SORT(v) sort(all(v))
#define INF 1000000007
#define fcout cout << fixed << setprecision(15)
typedef long long ll;
typedef pair<int, int> P;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; };
int lcm(int a, int b) { return a * b / gcd(a, b); };
int mod(int a, int b) { return (a + b - 1) / b; };
int month[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
};
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
ll h[100010];
rep(i, n) cin >> h[i];
ll dp[100100];
fill(dp, dp + 100100, INF);
dp[0] = 0;
rep(i, n) {
REP(j, 1, k + 1) {
dp[i + j] = min(dp[i + j], (dp[i] + abs(h[i] - h[i + j])));
}
}
cout << dp[n - 1] << endl;
return 0;
}
| [
"variable_declaration.type.change",
"identifier.replace.remove",
"literal.replace.add",
"variable_declaration.array_dimensions.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 960,206 | 960,204 | u681869152 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i, m, n) for (int i = m; i < n; i++)
#define SORT(v) sort(all(v))
#define INF 1000000007
#define fcout cout << fixed << setprecision(15)
typedef long long ll;
typedef pair<int, int> P;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; };
int lcm(int a, int b) { return a * b / gcd(a, b); };
int mod(int a, int b) { return (a + b - 1) / b; };
int month[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
};
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
int h[n];
rep(i, n) cin >> h[i];
ll dp[n];
fill(dp, dp + n, INF);
dp[0] = 0;
rep(i, n) {
REP(j, 1, k + 1) {
dp[i + j] = min(dp[i + j], (dp[i] + abs(h[i] - h[i + j])));
}
}
cout << dp[n - 1] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i, m, n) for (int i = m; i < n; i++)
#define SORT(v) sort(all(v))
#define INF 1000000007
#define fcout cout << fixed << setprecision(15)
typedef long long ll;
typedef pair<int, int> P;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; };
int lcm(int a, int b) { return a * b / gcd(a, b); };
int mod(int a, int b) { return (a + b - 1) / b; };
int month[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
};
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
ll h[100010];
rep(i, n) cin >> h[i];
ll dp[100100];
fill(dp, dp + 100100, INF);
dp[0] = 0;
rep(i, n) {
REP(j, 1, k + 1) {
dp[i + j] = min(dp[i + j], (dp[i] + abs(h[i] - h[i + j])));
}
}
cout << dp[n - 1] << endl;
return 0;
}
| [
"variable_declaration.type.change",
"identifier.replace.remove",
"literal.replace.add",
"variable_declaration.array_dimensions.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 960,206 | 960,208 | u681869152 | cpp |
p03161 | #include <algorithm>
#include <complex>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stdio.h>
#include <string.h>
#include <string>
#include <time.h>
#include <vector>
using namespace std;
typedef long long int llint;
typedef pair<int, int> pint;
typedef pair<llint, llint> pllint;
typedef vector<int> vint;
typedef vector<llint> vllint;
typedef vector<pint> vpint;
typedef vector<string> vstring;
typedef vector<pair<llint, llint>> vpllint;
typedef vector<vector<int>> vvint;
typedef vector<vector<llint>> vvllint;
typedef vector<vector<pint>> vvpint;
typedef vector<bool> vbool;
#define rep(i, n) for (int i = 0; i < n; i++)
#define drep(i, n) for (int i = n - 1; 0 <= i; i--)
#define yes(ans) \
if (ans) \
cout << "yes" << endl; \
else \
cout << "no" << endl;
#define Yes(ans) \
if (ans) \
cout << "Yes" << endl; \
else \
cout << "No" << endl;
#define YES(ans) \
if (ans) \
cout << "YES" << endl; \
else \
cout << "NO" << endl;
#define POSSIBLE(ans) \
if (ans) \
cout << "POSSIBLE" << endl; \
else \
cout << "IMPOSSIBLE" << endl;
#define Pi 3.1415926535897932384626
#define mod llint(1e9 + 7)
class UnionFind {
public:
//親の番号を格納する。親だった場合は-(その集合のサイズ)
vector<int> Parent;
//作るときはParentの値を全て-1にする
//こうすると全てバラバラになる
UnionFind(int N) { Parent = vector<int>(N, -1); }
// Aがどのグループに属しているか調べる
int root(int A) {
if (Parent[A] < 0)
return A;
return Parent[A] = root(Parent[A]);
}
//自分のいるグループの頂点数を調べる
int size(int A) {
return -Parent[root(A)]; //親をとってきたい
}
// AとBをくっ付ける
bool connect(int A, int B) {
// AとBを直接つなぐのではなく、root(A)にroot(B)をくっつける
A = root(A);
B = root(B);
if (A == B) {
//すでにくっついてるからくっ付けない
return false;
}
//大きい方(A)に小さいほう(B)をくっ付けたい
//大小が逆だったらひっくり返しちゃう。
if (size(A) < size(B))
swap(A, B);
// Aのサイズを更新する
Parent[A] += Parent[B];
// Bの親をAに変更する
Parent[B] = A;
return true;
}
};
// aとbの最大公約数を求めるよ
long long GCD(long long a, long long b) {
if (b == 0)
return a;
else
return GCD(b, a % b);
}
// 返り値: a と b の最大公約数
// ax + by = gcd(a, b) を満たす (x, y) が格納される
long long extGCD(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long d = extGCD(b, a % b, y, x);
y -= a / b * x;
return d;
}
bool check(llint a, llint b) { return a > b; }
// mod. m での a の逆元 a^{-1} を計算する
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
// aCbを1000000007で割った余りを求める
llint convination(llint a, llint b) {
llint ans = 1;
for (llint i = 0; i < b; i++) {
ans *= a - i;
ans %= 1000000007;
}
for (llint i = 1; i <= b; i++) {
ans *= modinv(i, 1000000007);
ans %= 1000000007;
}
return ans;
}
// aのb乗をmodで割った余りを求める
llint power(llint a, llint b) {
if (b == 1)
return a;
if (b == 0)
return 1;
llint tmp = power(a, (llint)b / 2);
tmp *= tmp;
tmp %= mod;
if (b % 2 == 1) {
tmp *= a;
tmp %= mod;
}
return tmp;
}
int main() {
int n, k;
cin >> n >> k;
vint a(n);
rep(i, n) cin >> a[i];
vint dp(n, 1 << 8);
dp[0] = 0;
rep(i, n) {
for (int j = 1; j <= k; j++) {
if (i + j < n) {
dp[i + j] = min(dp[i + j], dp[i] + abs(a[i] - a[i + j]));
}
}
}
cout << dp[n - 1] << endl;
return 0;
}
| #include <algorithm>
#include <complex>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stdio.h>
#include <string.h>
#include <string>
#include <time.h>
#include <vector>
using namespace std;
typedef long long int llint;
typedef pair<int, int> pint;
typedef pair<llint, llint> pllint;
typedef vector<int> vint;
typedef vector<llint> vllint;
typedef vector<pint> vpint;
typedef vector<string> vstring;
typedef vector<pair<llint, llint>> vpllint;
typedef vector<vector<int>> vvint;
typedef vector<vector<llint>> vvllint;
typedef vector<vector<pint>> vvpint;
typedef vector<bool> vbool;
#define rep(i, n) for (int i = 0; i < n; i++)
#define drep(i, n) for (int i = n - 1; 0 <= i; i--)
#define yes(ans) \
if (ans) \
cout << "yes" << endl; \
else \
cout << "no" << endl;
#define Yes(ans) \
if (ans) \
cout << "Yes" << endl; \
else \
cout << "No" << endl;
#define YES(ans) \
if (ans) \
cout << "YES" << endl; \
else \
cout << "NO" << endl;
#define POSSIBLE(ans) \
if (ans) \
cout << "POSSIBLE" << endl; \
else \
cout << "IMPOSSIBLE" << endl;
#define Pi 3.1415926535897932384626
#define mod llint(1e9 + 7)
class UnionFind {
public:
//親の番号を格納する。親だった場合は-(その集合のサイズ)
vector<int> Parent;
//作るときはParentの値を全て-1にする
//こうすると全てバラバラになる
UnionFind(int N) { Parent = vector<int>(N, -1); }
// Aがどのグループに属しているか調べる
int root(int A) {
if (Parent[A] < 0)
return A;
return Parent[A] = root(Parent[A]);
}
//自分のいるグループの頂点数を調べる
int size(int A) {
return -Parent[root(A)]; //親をとってきたい
}
// AとBをくっ付ける
bool connect(int A, int B) {
// AとBを直接つなぐのではなく、root(A)にroot(B)をくっつける
A = root(A);
B = root(B);
if (A == B) {
//すでにくっついてるからくっ付けない
return false;
}
//大きい方(A)に小さいほう(B)をくっ付けたい
//大小が逆だったらひっくり返しちゃう。
if (size(A) < size(B))
swap(A, B);
// Aのサイズを更新する
Parent[A] += Parent[B];
// Bの親をAに変更する
Parent[B] = A;
return true;
}
};
// aとbの最大公約数を求めるよ
long long GCD(long long a, long long b) {
if (b == 0)
return a;
else
return GCD(b, a % b);
}
// 返り値: a と b の最大公約数
// ax + by = gcd(a, b) を満たす (x, y) が格納される
long long extGCD(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long d = extGCD(b, a % b, y, x);
y -= a / b * x;
return d;
}
bool check(llint a, llint b) { return a > b; }
// mod. m での a の逆元 a^{-1} を計算する
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
// aCbを1000000007で割った余りを求める
llint convination(llint a, llint b) {
llint ans = 1;
for (llint i = 0; i < b; i++) {
ans *= a - i;
ans %= 1000000007;
}
for (llint i = 1; i <= b; i++) {
ans *= modinv(i, 1000000007);
ans %= 1000000007;
}
return ans;
}
// aのb乗をmodで割った余りを求める
llint power(llint a, llint b) {
if (b == 1)
return a;
if (b == 0)
return 1;
llint tmp = power(a, (llint)b / 2);
tmp *= tmp;
tmp %= mod;
if (b % 2 == 1) {
tmp *= a;
tmp %= mod;
}
return tmp;
}
int main() {
int n, k;
cin >> n >> k;
vint a(n);
rep(i, n) cin >> a[i];
vint dp(n, pow(10, 9));
dp[0] = 0;
rep(i, n) {
for (int j = 1; j <= k; j++) {
if (i + j < n) {
dp[i + j] = min(dp[i + j], dp[i] + abs(a[i] - a[i + j]));
}
}
}
cout << dp[n - 1] << endl;
return 0;
}
| [
"call.arguments.add"
] | 960,215 | 960,216 | u376082984 | cpp |
p03161 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n, i, j, k;
cin >> n >> k;
int a[n], ans[n];
for (int i = 0; i < n; i++)
cin >> a[i];
fill(ans, ans + n, 100000);
ans[0] = 0;
for (i = 1; i < n; i++) {
for (j = 1; j <= k; j++) {
if (j <= i) {
ans[i] = min(ans[i], ans[i - j] + abs(a[i] - a[i - j]));
} else
break;
}
}
cout << ans[n - 1] << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n, i, j, k;
cin >> n >> k;
int a[n], ans[n];
for (int i = 0; i < n; i++)
cin >> a[i];
fill(ans, ans + n, 2147483647);
ans[0] = 0;
for (i = 1; i < n; i++) {
for (j = 1; j <= k; j++) {
if (j <= i) {
ans[i] = min(ans[i], ans[i - j] + abs(a[i] - a[i - j]));
} else
break;
}
}
cout << ans[n - 1] << endl;
return 0;
} | [
"literal.number.change",
"call.arguments.change"
] | 960,223 | 960,224 | u984222407 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
int i, j, k;
int n;
int height[int(1e6)];
int cache[int(1e6)];
int dp(int x, int k) {
int miner = 10000;
if (x == 0) {
return 0;
}
if (cache[x] != -1) {
return cache[x];
} else {
for (int b = 1; b < k + 1; b++) {
if (x - b >= 0) {
miner = min(dp(x - b, k) + abs(height[x] - height[x - b]), miner);
}
}
return cache[x] = miner;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n >> k;
for (i = 0; i < n; i++) {
cin >> height[i];
cache[i] = -1;
}
cout << dp(n - 1, k) << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
int i, j, k;
int n;
int height[int(1e6)];
int cache[int(1e6)];
int dp(int x, int k) {
int miner = INT_MAX;
if (x == 0) {
return 0;
}
if (cache[x] != -1) {
return cache[x];
} else {
for (int b = 1; b < k + 1; b++) {
if (x - b >= 0) {
miner = min(dp(x - b, k) + abs(height[x] - height[x - b]), miner);
}
}
return cache[x] = miner;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n >> k;
for (i = 0; i < n; i++) {
cin >> height[i];
cache[i] = -1;
}
cout << dp(n - 1, k) << endl;
} | [
"variable_declaration.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 960,230 | 960,231 | u915971307 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> h(n + 1), ans(n + 1);
for (int i = 1; i <= n; i++)
cin >> h[i];
ans[1] = 0;
ans[2] = abs(h[2] - h[1]);
int mini = INT_MAX;
for (int i = 3; i <= n; i++) {
mini = INT_MAX;
for (int j = max(0, i - k); j <= i - 1; j++) {
mini = min(mini, ans[j] + abs(h[i] - h[j]));
}
ans[i] = mini;
}
cout << ans[n];
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> h(n + 1), ans(n + 1);
for (int i = 1; i <= n; i++)
cin >> h[i];
ans[1] = 0;
ans[2] = abs(h[2] - h[1]);
int mini = INT_MAX;
for (int i = 3; i <= n; i++) {
mini = INT_MAX;
for (int j = max(1, i - k); j <= i - 1; j++) {
mini = min(mini, ans[j] + abs(h[i] - h[j]));
}
ans[i] = mini;
}
cout << ans[n];
return 0;
} | [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"call.arguments.change"
] | 960,232 | 960,233 | u035413032 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, i, j;
cin >> n >> k;
int cost[n];
int h[n];
cost[0] = 0;
for (int i = 0; i < n; i++) {
cin >> h[i];
}
cost[1] = abs(h[1] - h[0]);
for (i = 2; i < n; i++) {
int x = INT_MAX;
j = 1;
// cout<<"i="<<i<<endl;
if (k < i) {
while (j <= k) {
x = min((cost[i - j] + abs(h[i] - h[i - j])), x);
// cout<<"j="<<j<<endl;
// cout<<"x="<<x<<endl;
j++;
}
cost[i] = x;
} else {
j = i - 1;
while (j >= 0) {
x = min((cost[j] + abs(h[i] - h[j])), x);
// cout<<"j="<<j<<endl;
// cout<<"x="<<x<<endl;
j++;
}
cost[i] = x;
}
}
cout << cost[n - 1] << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, i, j;
cin >> n >> k;
int cost[n];
int h[n];
cost[0] = 0;
for (int i = 0; i < n; i++) {
cin >> h[i];
}
cost[1] = abs(h[1] - h[0]);
for (i = 2; i < n; i++) {
int x = INT_MAX;
j = 1;
// cout<<"i="<<i<<endl;
if (k <= i) {
// cout<<"if================="<<endl;
while (j <= k) {
x = min((cost[i - j] + abs(h[i] - h[i - j])), x);
// cout<<"j="<<j<<endl;
// cout<<"x="<<x<<endl;
j++;
}
cost[i] = x;
} else {
// cout<<"else================"<<endl;
j = i - 1;
while (j >= 0) {
x = min((cost[j] + abs(h[i] - h[j])), x);
// cout<<"j="<<j<<endl;
// cout<<"x="<<x<<endl;
j--;
}
cost[i] = x;
}
}
cout << cost[n - 1] << endl;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 960,234 | 960,235 | u135151538 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, i, j;
cin >> n >> k;
int cost[n];
int h[n];
cost[0] = 0;
for (int i = 0; i < n; i++) {
cin >> h[i];
}
cost[1] = abs(h[1] - h[0]);
for (i = 2; i < n; i++) {
int x = INT_MAX;
j = 1;
// cout<<"i="<<i<<endl;
if (k < n) {
while (j <= k) {
x = min((cost[i - j] + abs(h[i] - h[i - j])), x);
// cout<<"j="<<j<<endl;
// cout<<"x="<<x<<endl;
j++;
}
cost[i] = x;
} else {
j = i - 1;
while (j >= 0) {
x = min((cost[j] + abs(h[i] - h[j])), x);
// cout<<"j="<<j<<endl;
// cout<<"x="<<x<<endl;
j++;
}
cost[i] = x;
}
}
cout << cost[n - 1] << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, i, j;
cin >> n >> k;
int cost[n];
int h[n];
cost[0] = 0;
for (int i = 0; i < n; i++) {
cin >> h[i];
}
cost[1] = abs(h[1] - h[0]);
for (i = 2; i < n; i++) {
int x = INT_MAX;
j = 1;
// cout<<"i="<<i<<endl;
if (k <= i) {
// cout<<"if================="<<endl;
while (j <= k) {
x = min((cost[i - j] + abs(h[i] - h[i - j])), x);
// cout<<"j="<<j<<endl;
// cout<<"x="<<x<<endl;
j++;
}
cost[i] = x;
} else {
// cout<<"else================"<<endl;
j = i - 1;
while (j >= 0) {
x = min((cost[j] + abs(h[i] - h[j])), x);
// cout<<"j="<<j<<endl;
// cout<<"x="<<x<<endl;
j--;
}
cost[i] = x;
}
}
cout << cost[n - 1] << endl;
} | [
"control_flow.loop.for.condition.change"
] | 960,236 | 960,235 | u135151538 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define be begin
#define en end
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define ALL(a) (a).be(), (a).en()
using LL = long long;
template <typename T> using V = vector<T>;
using Vi = V<int>;
using Vll = V<LL>;
using Vs = V<string>;
const LL INFLL = 999999999999999LL;
template <typename A, size_t N, typename T>
void FILL(A (&array)[N], const T &val) {
fill((T *)array, (T *)(array + N), val);
}
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;
}
LL dp[100005];
int main() {
int n, k;
cin >> n >> k;
Vi h(n);
for (int i = 0; i < n; i++) {
cin >> h[i];
}
FILL(dp, INFLL);
dp[0] = 0;
for (int i = 1; i < n; i++) {
int w = ((i - k >= 0) ? k : k - 1);
for (int j = 1; j <= w; j++)
chmin(dp[i], dp[i - j] + abs(h[i - j] - h[i]));
}
cout << dp[n - 1] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define be begin
#define en end
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define ALL(a) (a).be(), (a).en()
using LL = long long;
template <typename T> using V = vector<T>;
using Vi = V<int>;
using Vll = V<LL>;
using Vs = V<string>;
const LL INFLL = 999999999999999LL;
template <typename A, size_t N, typename T>
void FILL(A (&array)[N], const T &val) {
fill((T *)array, (T *)(array + N), val);
}
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;
}
LL dp[100005];
int main() {
int n, k;
cin >> n >> k;
Vi h(n);
for (int i = 0; i < n; i++) {
cin >> h[i];
}
FILL(dp, INFLL);
dp[0] = 0;
for (int i = 1; i < n; i++) {
int w = ((i - k >= 0) ? k : i);
for (int j = 1; j <= w; j++)
chmin(dp[i], dp[i - j] + abs(h[i - j] - h[i]));
}
cout << dp[n - 1] << endl;
return 0;
} | [
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 960,243 | 960,244 | u129220625 | cpp |
p03161 | #include <algorithm>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>
#define REP(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
int main() {
int n, k;
cin >> n >> k;
int arr[n];
for (int i = 0; i < n; i++)
cin >> arr[i];
int ans[n];
ans[0] = 0;
ans[1] = abs(arr[1] - arr[0]);
for (int i = 2; i < n; i++) {
ans[i] = INT_MAX;
int l = i - 1;
for (int j = 0; j < k; j++) {
ans[i] = min(ans[i], ans[l] + abs(arr[i] - arr[l]));
l--;
}
}
cout << ans[n - 1];
return 0;
}
| #include <algorithm>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>
#define REP(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
int main() {
int n, k;
cin >> n >> k;
int arr[n];
for (int i = 0; i < n; i++)
cin >> arr[i];
int ans[n];
ans[0] = 0;
ans[1] = abs(arr[1] - arr[0]);
for (int i = 2; i < n; i++) {
ans[i] = INT_MAX;
int l = i - 1;
for (int j = 0; j < k && l >= 0; j++) {
ans[i] = min(ans[i], ans[l] + abs(arr[i] - arr[l]));
l--;
}
}
cout << ans[n - 1];
return 0;
}
| [
"control_flow.loop.for.condition.change"
] | 960,245 | 960,246 | u796511558 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define fastio \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define INF 0x3f3f3f3f3f
int main() {
fastio;
ll n, k;
vector<ll> height(100005);
vector<ll> dp(100005);
cin >> n >> k;
for (ll i = 0; i < n; i++)
cin >> height[i];
// OPTIMAL SUBPROBLEM :
// dp[i] = total minimum penalty incurred after jumping to the ith stone
// BASE CASE :
dp[0] = 0;
for (ll i = 1; i < n; i++)
dp[i] = INF;
for (ll i = 1; i < k; i++) {
for (ll j = i - 1; j >= 0; j--) {
dp[i] = min(dp[i], abs(height[j] - height[i]));
}
}
// RECURSIVE RELATION :
for (ll i = k; i < n; i++) {
for (ll j = i - 1; j >= i - k; j--) {
dp[i] = min(dp[j] + abs(height[i] - height[j]), dp[i]);
}
}
// OPTIMAL SOLUTION :
cout << dp[n - 1];
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define fastio \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define INF 0x3f3f3f3f3f
int main() {
fastio;
ll n, k;
vector<ll> height(100005);
vector<ll> dp(100005);
cin >> n >> k;
for (ll i = 0; i < n; i++)
cin >> height[i];
// OPTIMAL SUBPROBLEM :
// dp[i] = total minimum penalty incurred after jumping to the ith stone
// BASE CASE :
dp[0] = 0;
for (ll i = 1; i < n; i++)
dp[i] = INF;
for (ll i = 1; i < k; i++) {
for (ll j = i - 1; j >= 0; j--) {
dp[i] = min(dp[i], dp[j] + abs(height[j] - height[i]));
}
}
// RECURSIVE RELATION :
for (ll i = k; i < n; i++) {
for (ll j = i - 1; j >= i - k; j--) {
dp[i] = min(dp[j] + abs(height[i] - height[j]), dp[i]);
}
}
// OPTIMAL SOLUTION :
cout << dp[n - 1];
return 0;
} | [
"assignment.change"
] | 960,252 | 960,253 | u494377156 | cpp |
p03161 | #include <bits/stdc++.h>
#define pb push_back
#define ll long long
using namespace std;
// can use O(K) memory actually
int T, n, k;
const int maxn = 100000 + 5;
const ll INF = 1000000000 + 5;
ll h[maxn];
ll dp[maxn];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> h[i];
dp[i] = INF;
}
dp[1] = 0LL;
for (int i = 2; i <= n; i++)
for (int j = max(1, j - k); j < i; j++)
dp[i] = min(dp[i], dp[j] + abs(h[i] - h[j]));
cout << dp[n];
return 0;
}
| #include <bits/stdc++.h>
#define pb push_back
#define ll long long
using namespace std;
// can use O(K) memory actually
int T, n, k;
const int maxn = 100000 + 5;
const ll INF = 1000000000 + 5;
ll h[maxn];
ll dp[maxn];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> h[i];
dp[i] = INF;
}
dp[1] = 0LL;
for (int i = 2; i <= n; i++)
for (int j = max(1, i - k); j < i; j++)
dp[i] = min(dp[i], dp[j] + abs(h[i] - h[j]));
cout << dp[n];
return 0;
}
| [
"identifier.change",
"control_flow.loop.for.initializer.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 960,259 | 960,260 | u065621181 | cpp |
p03161 | #include <bits/stdc++.h>
#define pb push_back
#define ll long long
using namespace std;
// can use O(K) memory actually
int T, n, k;
const int maxn = 100000 + 5;
const ll INF = 1000000000 + 5;
ll h[maxn];
ll dp[maxn];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> h[i];
dp[i] = INF;
}
dp[1] = 0LL;
for (int i = 2; i <= n; i++)
for (int j = min(1, j - k); j < i; j++)
dp[i] = min(dp[i], dp[j] + abs(h[i] - h[j]));
cout << dp[n];
return 0;
}
| #include <bits/stdc++.h>
#define pb push_back
#define ll long long
using namespace std;
// can use O(K) memory actually
int T, n, k;
const int maxn = 100000 + 5;
const ll INF = 1000000000 + 5;
ll h[maxn];
ll dp[maxn];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> h[i];
dp[i] = INF;
}
dp[1] = 0LL;
for (int i = 2; i <= n; i++)
for (int j = max(1, i - k); j < i; j++)
dp[i] = min(dp[i], dp[j] + abs(h[i] - h[j]));
cout << dp[n];
return 0;
}
| [
"misc.opposites",
"identifier.change",
"call.function.change",
"control_flow.loop.for.initializer.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 960,261 | 960,260 | u065621181 | cpp |
p03161 | #include <bits/stdc++.h>
#define pb push_back
#define ll long long
using namespace std;
// can use O(K) memory actually
int T, n, k;
const int maxn = 100000 + 5;
const ll INF = 1000000000 + 5;
ll h[maxn];
ll dp[maxn];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> h[i];
dp[i] = INF;
}
dp[1] = 0LL;
for (int i = 3; i <= n; i++)
for (int j = min(1, j - k); j < i; j++)
dp[i] = min(dp[i], dp[j] + abs(h[i] - h[j]));
cout << dp[n];
return 0;
}
| #include <bits/stdc++.h>
#define pb push_back
#define ll long long
using namespace std;
// can use O(K) memory actually
int T, n, k;
const int maxn = 100000 + 5;
const ll INF = 1000000000 + 5;
ll h[maxn];
ll dp[maxn];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> h[i];
dp[i] = INF;
}
dp[1] = 0LL;
for (int i = 2; i <= n; i++)
for (int j = max(1, i - k); j < i; j++)
dp[i] = min(dp[i], dp[j] + abs(h[i] - h[j]));
cout << dp[n];
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"misc.opposites",
"identifier.change",
"call.function.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 960,262 | 960,260 | u065621181 | cpp |
p03161 | #include <bits/stdc++.h>
#define ll long long
#define ld long double
#define pi acos(-1)
#define cross(a, b) (conj(a) * (b)).imag()
#define dot(a, b) (conj(a) * (b)).real()
#define vec(a, b) b - a
#define Reka \
ios_base::sync_with_stdio(0); \
cin.tie(0);
using namespace std;
int n;
int cost[999999];
int c[999999];
int x;
int jump(int ind) {
if (ind == n - 1)
return c[ind] = 0;
if (c[ind] != -1)
return c[ind];
int r = 1e9, ans = 99999;
for (int i = 1; i <= x; i++) {
if (ind + i < n) {
r = jump(ind + i) + abs(cost[ind] - cost[ind + i]);
ans = min(ans, r);
} else
break;
}
return c[ind] = ans;
}
int main() {
Reka memset(c, -1, sizeof(c));
cin >> n >> x;
for (int i = 0; i < n; i++) {
cin >> cost[i];
}
cout << jump(0);
return 0;
}
| #include <bits/stdc++.h>
#define ll long long
#define ld long double
#define pi acos(-1)
#define cross(a, b) (conj(a) * (b)).imag()
#define dot(a, b) (conj(a) * (b)).real()
#define vec(a, b) b - a
#define Reka \
ios_base::sync_with_stdio(0); \
cin.tie(0);
using namespace std;
int n;
int cost[999999];
int c[999999];
int x;
int jump(int ind) {
if (ind == n - 1)
return c[ind] = 0;
if (c[ind] != -1)
return c[ind];
int r = 1e9, ans = 1e9;
for (int i = 1; i <= x; i++) {
if (ind + i < n) {
r = jump(ind + i) + abs(cost[ind] - cost[ind + i]);
ans = min(ans, r);
} else
break;
}
return c[ind] = ans;
}
int main() {
Reka memset(c, -1, sizeof(c));
cin >> n >> x;
for (int i = 0; i < n; i++) {
cin >> cost[i];
}
cout << jump(0);
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change"
] | 960,265 | 960,266 | u805875050 | cpp |
p03161 | #include <bits/stdc++.h>
#define ll long long
#define ld long double
#define pi acos(-1)
#define cross(a, b) (conj(a) * (b)).imag()
#define dot(a, b) (conj(a) * (b)).real()
#define vec(a, b) b - a
#define Reka \
ios_base::sync_with_stdio(0); \
cin.tie(0);
using namespace std;
int n;
int cost[999999];
int c[999999];
int x;
int jump(int ind) {
if (ind == n - 1)
return c[ind] = 0;
if (c[ind] != -1)
return c[ind];
int r = 1e9, ans;
for (int i = 1; i <= x; i++) {
if (ind + i < n) {
r = jump(ind + i) + abs(cost[ind] - cost[ind + i]);
ans = min(ans, r);
} else
break;
}
return c[ind] = ans;
}
int main() {
Reka memset(c, -1, sizeof(c));
cin >> n >> x;
for (int i = 0; i < n; i++) {
cin >> cost[i];
}
cout << jump(0);
return 0;
}
| #include <bits/stdc++.h>
#define ll long long
#define ld long double
#define pi acos(-1)
#define cross(a, b) (conj(a) * (b)).imag()
#define dot(a, b) (conj(a) * (b)).real()
#define vec(a, b) b - a
#define Reka \
ios_base::sync_with_stdio(0); \
cin.tie(0);
using namespace std;
int n;
int cost[999999];
int c[999999];
int x;
int jump(int ind) {
if (ind == n - 1)
return c[ind] = 0;
if (c[ind] != -1)
return c[ind];
int r = 1e9, ans = 1e9;
for (int i = 1; i <= x; i++) {
if (ind + i < n) {
r = jump(ind + i) + abs(cost[ind] - cost[ind + i]);
ans = min(ans, r);
} else
break;
}
return c[ind] = ans;
}
int main() {
Reka memset(c, -1, sizeof(c));
cin >> n >> x;
for (int i = 0; i < n; i++) {
cin >> cost[i];
}
cout << jump(0);
return 0;
}
| [
"variable_declaration.value.change"
] | 960,267 | 960,266 | u805875050 | cpp |
p03161 | #include <iomanip>
#include <iostream>
#define nmax 100005
using namespace std;
int dp[nmax], p[nmax];
int modul(int x) {
if (x < 0) {
return -x;
}
return x;
}
int cost(int k, int i) { return dp[k] + modul(p[k] - p[i]); }
int main() {
int i, j, n, k;
cin >> n >> k;
for (i = 1; i <= n; i++)
cin >> p[i];
dp[2] = modul(p[1] - p[2]);
for (i = 3; i <= n; i++) {
dp[i] = 1000000000;
for (j = i - k; j <= i; j++)
dp[i] = min(dp[i], cost(j, i));
}
cout << dp[n];
}
| #include <iomanip>
#include <iostream>
#define nmax 100005
using namespace std;
int dp[nmax], p[nmax];
int modul(int x) {
if (x < 0) {
return -x;
}
return x;
}
int cost(int k, int i) { return dp[k] + modul(p[k] - p[i]); }
int main() {
int i, j, n, k;
cin >> n >> k;
for (i = 1; i <= n; i++)
cin >> p[i];
dp[2] = modul(p[1] - p[2]);
for (i = 3; i <= n; i++) {
dp[i] = 1000000000;
for (j = max(1, i - k); j <= i; j++)
dp[i] = min(dp[i], cost(j, i));
}
cout << dp[n];
}
| [
"control_flow.loop.for.initializer.change",
"call.add",
"call.arguments.change"
] | 960,268 | 960,269 | u384309758 | cpp |
p03161 | #include <climits>
#include <iostream>
using namespace std;
int main() {
int n, k;
cin >> n;
cin >> k;
int h[n];
int dp[n];
dp[0] = 0;
for (int i = 0; i < n; i++) {
cin >> h[i];
if (i == 0)
dp[0] = 0;
else
dp[i] = INT_MAX;
}
for (int i = 0; i < n; i++) {
for (int j = 1; j <= k; j++) {
dp[i + j] = min(dp[i + j], dp[i] + abs(h[i] - h[i + j]));
}
}
cout << dp[n - 1] << endl;
} | #include <climits>
#include <iostream>
using namespace std;
int main() {
int n, k;
cin >> n;
cin >> k;
int h[n];
int dp[n];
dp[0] = 0;
for (int i = 0; i < n; i++) {
cin >> h[i];
if (i == 0)
dp[0] = 0;
else
dp[i] = INT_MAX;
}
for (int i = 0; i < n; i++) {
for (int j = 1; j <= k && i + j < n; j++) {
dp[i + j] = min(dp[i + j], dp[i] + abs(h[i] - h[i + j]));
}
}
cout << dp[n - 1] << endl;
} | [
"control_flow.loop.for.condition.change"
] | 960,277 | 960,278 | u912318491 | cpp |
p03161 | #include <bits/stdc++.h>
#define FILE
using namespace std;
const int N = 2e5 + 100;
int n, k, h[N];
long long dp[N];
int main() {
#ifdef FILES
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(false);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> h[i];
}
for (int i = 2; i <= n; i++) {
dp[i] = 2e9;
for (int j = 1; j <= min(i, k); j++) {
dp[i] = min(dp[i], dp[i - j] + abs(h[i] - h[j]));
}
}
cout << dp[n];
return 0;
} | #include <bits/stdc++.h>
#define FILE
using namespace std;
const int N = 2e5 + 100;
int n, k, h[N];
long long dp[N];
int main() {
#ifdef FILEs
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(false);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> h[i];
}
for (int i = 2; i <= n; i++) {
dp[i] = 2e9;
for (int j = 1; j <= min(i - 1, k); j++) {
dp[i] = min(dp[i], dp[i - j] + abs(h[i] - h[i - j]));
}
}
cout << dp[n];
return 0;
} | [
"identifier.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 960,279 | 960,280 | u866968224 | cpp |
p03161 | #include <bits/stdc++.h>
#define FILE
using namespace std;
const int N = 2e5 + 100;
int n, k, h[N];
long long dp[N];
int main() {
#ifdef FILES
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(false);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> h[i];
}
for (int i = 2; i <= n; i++) {
dp[i] = 2e9;
for (int j = 1; j <= max(i, k); j++) {
dp[i] = min(dp[i], dp[i - j] + abs(h[i] - h[j]));
}
}
cout << dp[n];
return 0;
} | #include <bits/stdc++.h>
#define FILE
using namespace std;
const int N = 2e5 + 100;
int n, k, h[N];
long long dp[N];
int main() {
#ifdef FILEs
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(false);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> h[i];
}
for (int i = 2; i <= n; i++) {
dp[i] = 2e9;
for (int j = 1; j <= min(i - 1, k); j++) {
dp[i] = min(dp[i], dp[i - j] + abs(h[i] - h[i - j]));
}
}
cout << dp[n];
return 0;
} | [
"identifier.change",
"misc.opposites",
"call.function.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"misc.off_by_one"
] | 960,281 | 960,280 | u866968224 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
typedef long long int LL;
#define MAX(a, b) (a > b) ? a : b;
#define MIN(a, b) (a < b) ? a : b;
#define IsInteger(a) (fabs(a - round(a)) < 0.00001)
#define swap(a, b) \
{ \
a = a + b; \
b = a - b; \
a = a - b; \
}
int h[100001];
long long int cost[100001];
LL k;
long long int mincost(int currpos) {
if (cost[currpos] == -1) {
cost[currpos] =
(mincost(currpos - 1) + (LL)(fabs(h[currpos] - h[currpos - 1])));
for (LL j = currpos - 2; j >= currpos - k && j > -1; j--) {
LL now = mincost(j) + fabs(h[j] - h[currpos]);
if (now < cost[currpos]) {
cost[currpos] = now;
}
}
// cout<<"COST FOR POSITION "<<currpos<<" IS "<<cost[currpos]<<endl;
}
return cost[currpos];
}
int main() {
LL n;
cin >> n >> k;
h[0] = -1;
for (int i = 1; i <= n; i++) {
cin >> h[i];
cost[i] = -1;
}
for (int i = n + 1; i < 100001; i++) {
h[i] = -1;
cost[i] = -1;
}
cost[1] = 0;
// cout<<"h[1] is "<<h[1];
// cout<<"h[2] is "<<h[2];
cost[2] = fabs(h[2] - h[1]);
// cout<<cost[2]<<endl;
LL ans = mincost(n);
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long int LL;
#define MAX(a, b) (a > b) ? a : b;
#define MIN(a, b) (a < b) ? a : b;
#define IsInteger(a) (fabs(a - round(a)) < 0.00001)
#define swap(a, b) \
{ \
a = a + b; \
b = a - b; \
a = a - b; \
}
int h[100001];
long long int cost[100001];
LL k;
long long int mincost(int currpos) {
if (cost[currpos] == -1) {
cost[currpos] =
(mincost(currpos - 1) + (LL)(fabs(h[currpos] - h[currpos - 1])));
for (LL j = currpos - 2; j >= currpos - k && j > 0; j--) {
LL now = mincost(j) + (LL)fabs(h[j] - h[currpos]);
if (now < cost[currpos]) {
cost[currpos] = now;
}
}
// cout<<"COST FOR POSITION "<<currpos<<" IS "<<cost[currpos]<<endl;
}
return cost[currpos];
}
int main() {
LL n;
cin >> n >> k;
h[0] = -1;
for (int i = 1; i <= n; i++) {
cin >> h[i];
cost[i] = -1;
}
for (int i = n + 1; i < 100001; i++) {
h[i] = -1;
cost[i] = -1;
}
cost[1] = 0;
// cout<<"h[1] is "<<h[1];
// cout<<"h[2] is "<<h[2];
cost[2] = fabs(h[2] - h[1]);
// cout<<cost[2]<<endl;
LL ans = mincost(n);
cout << ans << endl;
return 0;
} | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 960,290 | 960,291 | u900249934 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
void solve();
int main() {
// freopen("SNOOKER.inp","r",stdin);
// freopen("SNOOKER.out","w",stdout);
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
solve();
}
/*----------------------------------------------------------------------
-----------------------------------------------------------------------*/
using ll = long long;
#define endl "\n"
#define eb emplace_back
#define all(x) x.begin(), x.end()
#define what_is(x) cerr << #x << " is :" << (x) << endl
const int MOD = 1e9 + 7;
const ll inf = LLONG_MAX;
const int MAX_N = 1e5 + 7;
int n, k;
ll a[MAX_N], dp[MAX_N];
void solve() {
fill(dp, dp + MAX_N, inf);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
dp[0] = dp[1] = 0;
dp[2] = abs(a[2] - a[1]);
for (int i = 3; i <= n; i++) {
for (int j = 1; j <= k; j++)
dp[i] = min(abs(a[i] - a[i - j]) + dp[i - j], dp[i]);
}
// for(int i = 1; i <= cur_lenght; i++) cout << tail[i] << endl;
cout << dp[n];
}
| #include <bits/stdc++.h>
using namespace std;
void solve();
int main() {
// freopen("SNOOKER.inp","r",stdin);
// freopen("SNOOKER.out","w",stdout);
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
solve();
}
/*----------------------------------------------------------------------
-----------------------------------------------------------------------*/
using ll = long long;
#define endl "\n"
#define eb emplace_back
#define all(x) x.begin(), x.end()
#define what_is(x) cerr << #x << " is :" << (x) << endl
const int MOD = 1e9 + 7;
const ll inf = LLONG_MAX;
const int MAX_N = 1e5 + 7;
int n, k;
ll a[MAX_N], dp[MAX_N];
void solve() {
fill(dp, dp + MAX_N, inf);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
dp[0] = dp[1] = 0;
dp[2] = abs(a[2] - a[1]);
for (int i = 3; i <= n; i++) {
for (int j = 1; j <= k && i - j > 0; j++)
dp[i] = min(abs(a[i] - a[i - j]) + dp[i - j], dp[i]);
}
cout << dp[n];
}
| [
"control_flow.loop.for.condition.change"
] | 960,292 | 960,293 | u307631662 | cpp |
p03161 | #include <cmath>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, i, x, k;
vector<int> h;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> x;
h.push_back(x);
}
vector<int> rasp(n + 1);
rasp[n - 1] = 0;
for (int i = n - 2; i >= 0; i--) {
if (i < k) {
rasp[i] = rasp[i + 1] + abs(h[i + 1] - h[i]);
for (int j = 2; i + j < n; j++)
rasp[i] = min(rasp[i + j] + abs(h[i + j] - h[i]), rasp[i]);
} else {
rasp[i] = rasp[i + 1] + abs(h[i + 1] - h[i]);
for (int j = 2; j <= k; j++)
rasp[i] = min(rasp[i + j] + abs(h[i + j] - h[i]), rasp[i]);
}
}
cout << rasp[0];
return 0;
}
| #include <cmath>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, i, x, k;
vector<int> h;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> x;
h.push_back(x);
}
vector<int> rasp(n + 1);
rasp[n - 1] = 0;
for (int i = n - 2; i >= 0; i--) {
if (i + k >= n) {
rasp[i] = rasp[i + 1] + abs(h[i + 1] - h[i]);
for (int j = 2; i + j < n; j++)
rasp[i] = min(rasp[i + j] + abs(h[i + j] - h[i]), rasp[i]);
} else {
rasp[i] = rasp[i + 1] + abs(h[i + 1] - h[i]);
for (int j = 2; j <= k; j++)
rasp[i] = min(rasp[i + j] + abs(h[i + j] - h[i]), rasp[i]);
}
}
cout << rasp[0];
return 0;
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 960,300 | 960,301 | u972879046 | cpp |
p03161 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
using namespace std;
int main() {
long long n, a, k;
cin >> n >> k;
int dp[123456] = {0}, test[123456] = {0};
for (int h = 0; h < n; h++) {
cin >> a;
test[h] = a;
}
for (int h = 1; h < 123456; h++) {
dp[h] = 12345;
}
for (int h = 1; h < n; h++) {
for (int i = 1; i <= k; i++) {
if (h - i >= 0) {
dp[h] = min(dp[h], dp[h - i] + abs(test[h - i] - test[h]));
}
}
}
cout << dp[n - 1] << endl;
cin >> n;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
using namespace std;
int main() {
long long n, a, k;
cin >> n >> k;
long long dp[123456] = {0}, test[123456] = {0};
for (int h = 0; h < n; h++) {
cin >> a;
test[h] = a;
}
for (int h = 1; h < 123456; h++) {
dp[h] = 1234567891234;
}
for (int h = 1; h < n; h++) {
for (int i = 1; i <= k; i++) {
if (h - i >= 0) {
dp[h] = min(dp[h], dp[h - i] + abs(test[h - i] - test[h]));
}
}
}
cout << dp[n - 1] << endl;
cin >> n;
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"literal.number.change",
"assignment.value.change"
] | 960,306 | 960,305 | u986568278 | cpp |
p03161 | #include <algorithm>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
#define Would
#define you
const int INF = 999999999;
const int MOD = 1e9 + 7;
int n, m, k[100005], dp[100005];
int main() {
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> k[i];
}
memset(dp, 99999, sizeof(dp));
dp[0] = 0;
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j <= i + m; ++j) {
dp[j] = min(dp[j], dp[i] + abs(k[i] - k[j]));
}
}
cout << dp[n - 1] << endl;
}
| #include <algorithm>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
#define Would
#define you
const int INF = 999999999;
const int MOD = 1e9 + 7;
long long n, m, k[100005], dp[100005];
int main() {
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> k[i];
}
memset(dp, 9999, sizeof(dp));
dp[0] = 0;
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j <= i + m; ++j) {
dp[j] = min(dp[j], dp[i] + abs(k[i] - k[j]));
}
}
cout << dp[n - 1] << endl;
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"literal.number.change",
"call.arguments.change"
] | 960,322 | 960,323 | u539402331 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
int main() {
#define int long long
int N, K;
cin >> N >> K;
int dp[N];
int a[N];
for (int i = 0; i < N; i++) {
cin >> a[i];
dp[i] = 100000;
// cout << a[i] << "\n";
}
dp[0] = 0;
for (int i = 1; i < N; i++) {
for (int j = i - 1; j >= i - K && j >= 0; j--) {
dp[i] = min(dp[i], dp[j] + abs(a[i] - a[j]));
}
}
/* cout << "\n";
for (int i = 0; i < N; i++)
{
cout << dp[i] << "\n";
} */
cout << dp[N - 1];
} | #include <bits/stdc++.h>
using namespace std;
int main() {
#define int long long
int N, K;
cin >> N >> K;
int dp[N];
int a[N];
for (int i = 0; i < N; i++) {
cin >> a[i];
dp[i] = LLONG_MAX;
// cout << a[i] << "\n";
}
dp[0] = 0;
for (int i = 1; i < N; i++) {
for (int j = i - 1; j >= i - K && j >= 0; j--) {
dp[i] = min(dp[i], dp[j] + abs(a[i] - a[j]));
}
}
/* cout << "\n";
for (int i = 0; i < N; i++)
{
cout << dp[i] << "\n";
} */
cout << dp[N - 1];
} | [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 960,325 | 960,326 | u730651258 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long ll;
int main() {
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<int> dp(n);
dp[0] = 0;
for (int i = 1; i < n; i++) {
int curMin = 99999;
for (int j = 1; j <= k; j++) {
if (i - j < 0)
break;
curMin = min(curMin, dp[i - j] + abs(a[i - j] - a[i]));
}
dp[i] = curMin;
}
cout << dp[n - 1] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long ll;
int main() {
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<int> dp(n);
dp[0] = 0;
for (int i = 1; i < n; i++) {
int curMin = INT32_MAX;
for (int j = 1; j <= k; j++) {
if (i - j < 0)
break;
curMin = min(curMin, dp[i - j] + abs(a[i - j] - a[i]));
}
dp[i] = curMin;
}
cout << dp[n - 1] << endl;
return 0;
}
| [
"variable_declaration.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 960,342 | 960,343 | u917793793 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
const long long INF = 1LL << 60;
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;
}
vector<long long> h(100010);
vector<long long> dp(100010, INF);
int main() {
int N, K;
cin >> N >> K;
for (int i = 0; i < N; i++)
cin >> h[i];
dp[0] = 0;
for (int i = 0; i < N; i++) {
for (int k = 1; k < K; k++) {
chmin(dp[i + k], dp[i] + abs(h[i] - h[i + k]));
}
}
cout << dp[N - 1] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const long long INF = 1LL << 60;
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;
}
vector<long long> h(100010);
vector<long long> dp(100010, INF);
int main() {
int N, K;
cin >> N >> K;
for (int i = 0; i < N; i++)
cin >> h[i];
dp[0] = 0;
for (int i = 0; i < N; i++) {
for (int k = 1; k <= K; k++) {
chmin(dp[i + k], dp[i] + abs(h[i] - h[i + k]));
}
}
cout << dp[N - 1] << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 960,344 | 960,345 | u485405254 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
/* attention
long longのシフト演算には気をつけよう
タイポした時のデバッグが死ぬほどきつくなるので変数名は最低3字くらい使った方がいいかも
sizeは(int)とキャストしよう
ごちゃごちゃ場合分けを考える前に全探索は考えましたか？
*/
const ll mod = 1e9 + 7;
void chmod(ll &M) {
if (M >= mod)
M %= mod;
else if (M < 0) {
M += (abs(M) / mod + 1) * mod;
M %= mod;
}
}
ll modpow(ll x, ll n) {
if (n == 0)
return 1;
ll res = modpow(x, n / 2);
if (n % 2 == 0)
return res * res % mod;
else
return res * res % mod * x % mod;
}
ll power(ll x, ll n) {
if (n == 0)
return 1;
ll res = power(x, n / 2);
if (n % 2 == 0)
return res * res;
else
return res * res * x;
}
int getl(int i, int N) { return i == 0 ? N - 1 : i - 1; };
int getr(int i, int N) { return i == N - 1 ? 0 : i + 1; };
/* <--------------------------------------------> */
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
const int inf = 1 << 30;
int n, k;
cin >> n >> k;
vector<ll> h(n + 5);
for (int i = 1; i <= n; ++i)
cin >> h[i];
vector<ll> dp(100005, inf);
dp[1] = 0;
for (int i = 1; i < n; ++i) {
for (int j = 1; j <= k; ++j) {
if (i + j > n)
continue;
chmin(dp[i + j], dp[i] + abs(h[i] - h[i + k]));
}
}
cout << dp[n] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
/* attention
long longのシフト演算には気をつけよう
タイポした時のデバッグが死ぬほどきつくなるので変数名は最低3字くらい使った方がいいかも
sizeは(int)とキャストしよう
ごちゃごちゃ場合分けを考える前に全探索は考えましたか？
*/
const ll mod = 1e9 + 7;
void chmod(ll &M) {
if (M >= mod)
M %= mod;
else if (M < 0) {
M += (abs(M) / mod + 1) * mod;
M %= mod;
}
}
ll modpow(ll x, ll n) {
if (n == 0)
return 1;
ll res = modpow(x, n / 2);
if (n % 2 == 0)
return res * res % mod;
else
return res * res % mod * x % mod;
}
ll power(ll x, ll n) {
if (n == 0)
return 1;
ll res = power(x, n / 2);
if (n % 2 == 0)
return res * res;
else
return res * res * x;
}
int getl(int i, int N) { return i == 0 ? N - 1 : i - 1; };
int getr(int i, int N) { return i == N - 1 ? 0 : i + 1; };
/* <--------------------------------------------> */
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
const int inf = 1 << 30;
int n, k;
cin >> n >> k;
vector<ll> h(n + 5);
for (int i = 1; i <= n; ++i)
cin >> h[i];
vector<ll> dp(100005, inf);
dp[1] = 0;
for (int i = 1; i < n; ++i) {
for (int j = 1; j <= k; ++j) {
if (i + j > n)
continue;
chmin(dp[i + j], dp[i] + abs(h[i] - h[i + j]));
}
}
cout << dp[n] << endl;
return 0;
}
| [
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 960,346 | 960,347 | u052332717 | cpp |
p03161 | // be name khoda \\
// #define stream_enable
// #define long_enable
#define debug_enable
#include <algorithm>
#include <cmath>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <vector>
using namespace std;
#ifdef stream_enable
#define cin sss
#endif
#ifdef long_enable
typedef long long int ll;
#else
typedef int ll;
#endif
typedef pair<ll, ll> pii;
typedef vector<ll> vi;
typedef pair<ll, pii> pip;
typedef pair<pii, ll> ppi;
typedef pair<pii, pii> ppp;
typedef vector<vi> vii;
typedef vector<vii> viii;
typedef vector<bool> vb;
typedef vector<vb> vbb;
typedef vector<pii> vpii;
typedef vector<pip> vpip;
const ll MOD = 1000000007;
const long long BIG = 1446803456761533460LL;
const int Big = 336860180;
#ifdef long_enable
const ll INF = LONG_LONG_MAX;
#else
const ll INF = INT_MAX;
#endif
const ll adj4[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
const ll adj8[8][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0},
{-1, -1}, {1, -1}, {-1, 1}, {1, 1}};
#define mp make_pair
#define ff first
#define ss second
#define all(x) (x).begin(), (x).end()
#define pb push_back
#define print(x) cout << (x) << '\n'
#define print2(x, y) cout << (x) << ' ' << (y) << '\n'
#define print3(x, y, z) cout << (x) << ' ' << (y) << ' ' << (z) << '\n'
#define print4(x, y, z, t) \
cout << (x) << ' ' << (y) << ' ' << (z) << ' ' << (t) << '\n'
#define printv(x) \
fori(j12345, (x).size()) { cout << (x)[j12345] << ' '; } \
cout << '\n'
#define printvv(x) \
fori(i123456, (x).size()) { \
fori(j123456, (x)[i123456].size()) { \
cout << (x)[i123456][j123456] << ' '; \
} \
cout << '\n'; \
}
#define printp(x) cout << "(" << x.ff << ", " << x.ss << ")" << '\n'
#define printvp(x) \
fori(i1234567, (x).size()) { \
cout << "(" << x[i1234567].ff << ", " << x[i1234567].ss << ")" << '\n'; \
}
#define printa(x, n) \
fori(ja12345, n) { cout << (x)[ja12345] << ' '; } \
cout << '\n'
#define printap(x, n) \
fori(ia1234567, n) { \
cout << "(" << x[ia1234567].ff << ", " << x[ia1234567].ss << ")" << '\n'; \
}
#define printaa(x, n, m) \
fori(iaa123456, n) { \
fori(jaa123456, m) { cout << (x)[iaa123456][jaa123456] << ' '; } \
cout << '\n'; \
}
#define printav(x, n) \
fori(iaa123477, n) { printv(x[iaa123477]); }
#define printia(x, n) \
fori(ja212345, n) { cout << ja212345 << " : " << (x)[ja212345] << '\n'; }
#ifdef debug_enable
#define debug(x) \
cout << #x << " -> "; \
print(x)
#define debug2(x, y) \
cout << #x << ' ' << #y << " -> "; \
print2(x, y)
#define debug3(x, y, z) \
cout << #x << ' ' << #y << ' ' << #z << " -> "; \
print3(x, y, z)
#define debug4(x, y, z, t) \
cout << #x << ' ' << #y << ' ' << #z << ' ' << #t << " -> "; \
print4(x, y, z, t)
#define debugv(x) \
cout << #x << " -> "; \
printv(x)
#define debugvv(x) \
cout << #x << " ->\n"; \
printvv(x)
#define debugp(x) \
cout << #x << " -> "; \
printp(x)
#define debugvp(x) \
cout << #x << " ->\n"; \
printvp(x)
#define debuga(x, n) \
cout << #x << " -> "; \
printa(x, n)
#define debugap(x, n) \
cout << #x << " ->\n"; \
printap(x, n)
#define debugaa(x, n, m) \
cout << #x << " ->\n"; \
printaa(x, n, m)
#define debugav(x, n) \
cout << #x << " ->\n"; \
printav(x, n)
#define debugia(x, n) \
cout << #x << " ->\n"; \
printia(x, n)
ll clk_ar[10];
#define clk_s(i) clk_ar[i] = clock();
#define clk_e(i) \
cout << "Clock " << i << " : " \
<< (double)(clock() - clk_ar[i]) / CLOCKS_PER_SEC << " sec\n";
#else
#define debug(x)
#define debug2(x, y)
#define debug3(x, y, z)
#define debug4(x, y, z, t)
#define debugv(x)
#define debugvv(x)
#define debugp(x)
#define debugvp(x)
#define debuga(x, n)
#define debugap(x, n)
#define debugaa(x, n, m)
#define debugav(x, n, m)
#define debugia(x, n)
#define clk_s(i)
#define clk_e(i)
#endif
#define fori(i, n) for (ll i = 0; i < (n); ++i)
#define forir(i, n) for (ll i = (n)-1; i >= 0; --i)
#define forifrom(i, f, n) for (ll i = (f); i < (n); ++i)
#define forirto(i, n, f) for (ll i = (n)-1; i >= (f); --i)
#define smin(a, b) a = min(a, (b))
#define smax(a, b) a = max(a, (b))
#define inp(x) \
ll x; \
cin >> x
#define inp2(x, y) \
ll x, y; \
cin >> x >> y
#define inp3(x, y, z) \
ll x, y, z; \
cin >> x >> y >> z
#define inp4(x, y, z, w) \
ll x, y, z, w; \
cin >> x >> y >> z >> w
ll gcd(ll a, ll b) { return b == 0 ? a : gcd(b, a % b); }
ll powMod(ll a, ll b) {
ll n = 1;
ll p = a;
while (b > 0) {
if (b % 2 == 1) {
n *= p;
n %= MOD;
}
p *= p;
p %= MOD;
b /= 2;
}
return n;
}
ll modularInverse(ll a) { return powMod(a, MOD - 2); }
stringstream sss;
// -----------------------------------------------------------------------
const ll maxn = 100010;
ll ar[maxn];
ll dp[maxn];
void MAIN() {
inp2(n, k);
fori(i, n) { cin >> ar[i]; }
memset(dp, 60, sizeof dp);
dp[0] = 0;
fori(i, n) {
fori(j, k) { smin(dp[i + j], dp[i] + abs(ar[i] - ar[i + j])); }
}
print(dp[n - 1]);
}
// -----------------------------------------------------------------------
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(10);
sss << R"(
)";
MAIN();
return 0;
}
| // be name khoda \\
// #define stream_enable
// #define long_enable
#define debug_enable
#include <algorithm>
#include <cmath>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <vector>
using namespace std;
#ifdef stream_enable
#define cin sss
#endif
#ifdef long_enable
typedef long long int ll;
#else
typedef int ll;
#endif
typedef pair<ll, ll> pii;
typedef vector<ll> vi;
typedef pair<ll, pii> pip;
typedef pair<pii, ll> ppi;
typedef pair<pii, pii> ppp;
typedef vector<vi> vii;
typedef vector<vii> viii;
typedef vector<bool> vb;
typedef vector<vb> vbb;
typedef vector<pii> vpii;
typedef vector<pip> vpip;
const ll MOD = 1000000007;
const long long BIG = 1446803456761533460LL;
const int Big = 336860180;
#ifdef long_enable
const ll INF = LONG_LONG_MAX;
#else
const ll INF = INT_MAX;
#endif
const ll adj4[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
const ll adj8[8][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0},
{-1, -1}, {1, -1}, {-1, 1}, {1, 1}};
#define mp make_pair
#define ff first
#define ss second
#define all(x) (x).begin(), (x).end()
#define pb push_back
#define print(x) cout << (x) << '\n'
#define print2(x, y) cout << (x) << ' ' << (y) << '\n'
#define print3(x, y, z) cout << (x) << ' ' << (y) << ' ' << (z) << '\n'
#define print4(x, y, z, t) \
cout << (x) << ' ' << (y) << ' ' << (z) << ' ' << (t) << '\n'
#define printv(x) \
fori(j12345, (x).size()) { cout << (x)[j12345] << ' '; } \
cout << '\n'
#define printvv(x) \
fori(i123456, (x).size()) { \
fori(j123456, (x)[i123456].size()) { \
cout << (x)[i123456][j123456] << ' '; \
} \
cout << '\n'; \
}
#define printp(x) cout << "(" << x.ff << ", " << x.ss << ")" << '\n'
#define printvp(x) \
fori(i1234567, (x).size()) { \
cout << "(" << x[i1234567].ff << ", " << x[i1234567].ss << ")" << '\n'; \
}
#define printa(x, n) \
fori(ja12345, n) { cout << (x)[ja12345] << ' '; } \
cout << '\n'
#define printap(x, n) \
fori(ia1234567, n) { \
cout << "(" << x[ia1234567].ff << ", " << x[ia1234567].ss << ")" << '\n'; \
}
#define printaa(x, n, m) \
fori(iaa123456, n) { \
fori(jaa123456, m) { cout << (x)[iaa123456][jaa123456] << ' '; } \
cout << '\n'; \
}
#define printav(x, n) \
fori(iaa123477, n) { printv(x[iaa123477]); }
#define printia(x, n) \
fori(ja212345, n) { cout << ja212345 << " : " << (x)[ja212345] << '\n'; }
#ifdef debug_enable
#define debug(x) \
cout << #x << " -> "; \
print(x)
#define debug2(x, y) \
cout << #x << ' ' << #y << " -> "; \
print2(x, y)
#define debug3(x, y, z) \
cout << #x << ' ' << #y << ' ' << #z << " -> "; \
print3(x, y, z)
#define debug4(x, y, z, t) \
cout << #x << ' ' << #y << ' ' << #z << ' ' << #t << " -> "; \
print4(x, y, z, t)
#define debugv(x) \
cout << #x << " -> "; \
printv(x)
#define debugvv(x) \
cout << #x << " ->\n"; \
printvv(x)
#define debugp(x) \
cout << #x << " -> "; \
printp(x)
#define debugvp(x) \
cout << #x << " ->\n"; \
printvp(x)
#define debuga(x, n) \
cout << #x << " -> "; \
printa(x, n)
#define debugap(x, n) \
cout << #x << " ->\n"; \
printap(x, n)
#define debugaa(x, n, m) \
cout << #x << " ->\n"; \
printaa(x, n, m)
#define debugav(x, n) \
cout << #x << " ->\n"; \
printav(x, n)
#define debugia(x, n) \
cout << #x << " ->\n"; \
printia(x, n)
ll clk_ar[10];
#define clk_s(i) clk_ar[i] = clock();
#define clk_e(i) \
cout << "Clock " << i << " : " \
<< (double)(clock() - clk_ar[i]) / CLOCKS_PER_SEC << " sec\n";
#else
#define debug(x)
#define debug2(x, y)
#define debug3(x, y, z)
#define debug4(x, y, z, t)
#define debugv(x)
#define debugvv(x)
#define debugp(x)
#define debugvp(x)
#define debuga(x, n)
#define debugap(x, n)
#define debugaa(x, n, m)
#define debugav(x, n, m)
#define debugia(x, n)
#define clk_s(i)
#define clk_e(i)
#endif
#define fori(i, n) for (ll i = 0; i < (n); ++i)
#define forir(i, n) for (ll i = (n)-1; i >= 0; --i)
#define forifrom(i, f, n) for (ll i = (f); i < (n); ++i)
#define forirto(i, n, f) for (ll i = (n)-1; i >= (f); --i)
#define smin(a, b) a = min(a, (b))
#define smax(a, b) a = max(a, (b))
#define inp(x) \
ll x; \
cin >> x
#define inp2(x, y) \
ll x, y; \
cin >> x >> y
#define inp3(x, y, z) \
ll x, y, z; \
cin >> x >> y >> z
#define inp4(x, y, z, w) \
ll x, y, z, w; \
cin >> x >> y >> z >> w
ll gcd(ll a, ll b) { return b == 0 ? a : gcd(b, a % b); }
ll powMod(ll a, ll b) {
ll n = 1;
ll p = a;
while (b > 0) {
if (b % 2 == 1) {
n *= p;
n %= MOD;
}
p *= p;
p %= MOD;
b /= 2;
}
return n;
}
ll modularInverse(ll a) { return powMod(a, MOD - 2); }
stringstream sss;
// -----------------------------------------------------------------------
const ll maxn = 100010;
ll ar[maxn];
ll dp[maxn];
void MAIN() {
inp2(n, k);
fori(i, n) { cin >> ar[i]; }
memset(dp, 60, sizeof dp);
dp[0] = 0;
fori(i, n) {
forifrom(j, 1, k + 1) { smin(dp[i + j], dp[i] + abs(ar[i] - ar[i + j])); }
}
print(dp[n - 1]);
}
// -----------------------------------------------------------------------
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(10);
sss << R"(
)";
MAIN();
return 0;
}
| [
"call.arguments.add"
] | 960,351 | 960,352 | u780597450 | cpp |
p03161 | #include <cmath>
#include <cstdio>
#include <iostream>
using namespace std;
#define MAXN 100010
#define ll long long
const ll INF = 1e18;
int n, k;
ll h[MAXN], f[MAXN];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i)
scanf("%lld", &h[i]);
for (int i = 2; i <= n; ++i) {
f[i] = INF;
for (int j = max(0, i - k); j < i; ++j)
f[i] = min(f[i], f[j] + abs(h[i] - h[j]));
}
printf("%lld", f[n]);
return 0;
} | #include <cmath>
#include <cstdio>
#include <iostream>
using namespace std;
#define MAXN 100010
#define ll long long
const ll INF = 1e18;
int n, k;
ll h[MAXN], f[MAXN];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i)
scanf("%lld", &h[i]);
for (int i = 2; i <= n; ++i) {
f[i] = INF;
for (int j = max(1, i - k); j < i; ++j)
f[i] = min(f[i], f[j] + (ll)abs(h[i] - h[j]));
}
printf("%lld", f[n]);
return 0;
} | [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"call.arguments.change"
] | 960,359 | 960,360 | u487696125 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int dp[n];
vector<int> cost(n);
for (int i = 0; i < n; i++)
scanf("%d", &dp[i]);
int minc;
for (int i = 1; i < n; i++) {
minc = 100000;
for (int j = 1; j <= k && i - j >= 0; j++) {
minc = min(minc, cost[i - j] + abs(dp[i] - dp[i - j]));
}
cost[i] = minc;
}
cout << cost[n - 1] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int dp[n];
vector<int> cost(n);
for (int i = 0; i < n; i++)
scanf("%d", &dp[i]);
int minc;
for (int i = 1; i < n; i++) {
minc = INT_MAX;
for (int j = 1; j <= k && i - j >= 0; j++) {
minc = min(minc, cost[i - j] + abs(dp[i] - dp[i - j]));
}
cost[i] = minc;
}
cout << cost[n - 1] << endl;
return 0;
} | [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 960,375 | 960,376 | u508355276 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, k;
cin >> N >> k;
int h[N]; // INPUT ARRAY
int ans[N]; // OUTPUT ARRAY
for (int i = 0; i < N; i++) {
cin >> h[i];
ans[i] = INT_MAX;
}
ans[0] = 0;
for (int i = 0; i < N; i++) {
for (int j = i + 1; j < N, j - i <= k; j++)
ans[j] = min(ans[j], ans[i] + abs(h[i] - h[j]));
}
cout << ans[N - 1];
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N, k;
cin >> N >> k;
int h[N]; // INPUT ARRAY
int ans[N]; // OUTPUT ARRAY
for (int i = 0; i < N; i++) {
cin >> h[i];
ans[i] = INT_MAX;
}
ans[0] = 0;
for (int i = 0; i < N; i++) {
for (int j = i + 1; j < N && j - i <= k; j++)
ans[j] = min(ans[j], ans[i] + abs(h[i] - h[j]));
}
cout << ans[N - 1];
return 0;
}
| [
"control_flow.loop.for.condition.change"
] | 960,386 | 960,387 | u120889780 | cpp |
p03161 | /*
このコード、と～おれ!
Be accepted!
∧＿∧
（｡･ω･｡)つ━☆・*。
⊂ ノ ・゜+.
しーＪ °。+ *´¨)
.· ´¸.·*´¨) ¸.·*¨)
(¸.·´ (¸.·'* ☆
*/
#include <algorithm>
#include <cmath>
#include <cstring>
#include <iostream>
#include <map>
#include <numeric>
#include <random>
#include <stdio.h>
#include <string>
#include <unordered_map>
#include <vector>
#pragma GCC optimize("Ofast")
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep1(i, n) for (int i = 1; i < (n); ++i)
#define repr(i, n) for (int i = n; i >= 0; --i)
#define reprm(i, n) for (int i = n - 1; i >= 0; --i)
#define printynl(a) printf(a ? "yes\n" : "no\n")
#define printyn(a) printf(a ? "Yes\n" : "No\n")
#define printYN(a) printf(a ? "YES\n" : "NO\n")
#define printin(a) printf(a ? "possible\n" : "inposible\n")
#define printdb(a) printf("%.16f\n", a) //少数出力
#define all(x) (x).begin(), (x).end()
#define allsum(a, b, c) ((a + b) * c / 2) //等差数列の和、初項,末項,項数
using ll = long long;
const int INF = 2147483647;
const int MINF = -2147483648;
const ll LINF = ll(9223372036854775807);
const ll MOD = 1000000007;
const double PI = acos(-1);
//マクロとかここまで
using namespace std;
int ggd(int number1, int number2) { // ggcを求める
int m = number1;
int n = number2;
if (number2 > number1) {
m = number2;
n = number1;
}
while (m != n) {
int temp = n;
n = m - n;
m = temp;
}
return m;
}
int lcm(int number1, int number2) { // lcmを求める
return number1 * number2 / ggd(number1, number2);
}
bool is_prime(int64_t x) { //素数判定
for (int64_t i = 2; i * i <= x; i++) {
if (x % i == 0)
return false;
}
return true;
}
ll nearPow2(ll n) // x以上の2のべき乗を返す
{
// nが0以下の時は0とする。
if (n <= 0)
return 0;
// (n & (n - 1)) == 0 の時は、nが2の冪乗であるため、そのままnを返す。
if ((n & (n - 1)) == 0)
return ll(n);
// bitシフトを用いて、2の冪乗を求める。
ll ret = 1;
while (n > 0) {
ret <<= 1;
n >>= 1;
}
return ret;
}
map<int64_t, int> prime_factor(int64_t n) { //素因数分解
map<int64_t, int> ret;
for (int64_t i = 2; i * i <= n; i++) {
while (n % i == 0) {
ret[i]++;
n /= i;
}
}
if (n != 1)
ret[n] = 1;
return ret;
}
template <int mod> struct ModInt {
int x;
ModInt() : x(0) {}
ModInt(int64_t y) : x(y >= 0 ? y % mod : (mod - (-y) % mod) % mod) {}
ModInt &operator+=(const ModInt &p) {
if ((x += p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator-=(const ModInt &p) {
if ((x += mod - p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator*=(const ModInt &p) {
x = (int)(1LL * x * p.x % mod);
return *this;
}
ModInt &operator/=(const ModInt &p) {
*this *= p.inverse();
return *this;
}
ModInt operator-() const { return ModInt(-x); }
ModInt operator+(const ModInt &p) const { return ModInt(*this) += p; }
ModInt operator-(const ModInt &p) const { return ModInt(*this) -= p; }
ModInt operator*(const ModInt &p) const { return ModInt(*this) *= p; }
ModInt operator/(const ModInt &p) const { return ModInt(*this) /= p; }
bool operator==(const ModInt &p) const { return x == p.x; }
bool operator!=(const ModInt &p) const { return x != p.x; }
ModInt inverse() const {
int a = x, b = mod, u = 1, v = 0, t;
while (b > 0) {
t = a / b;
swap(a -= t * b, b);
swap(u -= t * v, v);
}
return ModInt(u);
}
ModInt pow(int64_t n) const {
ModInt ret(1), mul(x);
while (n > 0) {
if (n & 1)
ret *= mul;
mul *= mul;
n >>= 1;
}
return ret;
}
friend ostream &operator<<(ostream &os, const ModInt &p) { return os << p.x; }
friend istream &operator>>(istream &is, ModInt &a) {
int64_t t;
is >> t;
a = ModInt<mod>(t);
return (is);
}
static int get_mod() { return mod; }
};
using modint = ModInt<MOD>; // MOD=10億7
// mod. m での a の逆元 a^{-1} を計算する
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
// aCbを1000000007で割った余りを求める
ll aCb(ll a, ll b) {
ll ans = 1;
for (ll i = 0; i < b; i++) {
ans *= a - i;
ans %= MOD;
}
for (ll i = 1; i <= b; i++) {
ans *= modinv(i, MOD);
ans %= MOD;
}
return ans;
}
/*-----------------------------------------ここまでライブラリとか-----------------------------------------*/
int main() {
int n, k, step = 0;
ll cost = 0;
scanf("%d%d", &n, &k);
vector<int> h(n);
rep(i, n) scanf("%d", &h[i]);
vector<int> dp(n);
dp[0] = 0;
rep1(i, n) {
dp[i] = INF;
for (int j = 1; j < k && i - j >= 0; ++j) {
dp[i] = min(dp[i], abs(h[i - j] - h[i]) + dp[i - j]);
}
}
printf("%d\n", dp[n - 1]);
return 0;
}
| /*
このコード、と～おれ!
Be accepted!
∧＿∧
（｡･ω･｡)つ━☆・*。
⊂ ノ ・゜+.
しーＪ °。+ *´¨)
.· ´¸.·*´¨) ¸.·*¨)
(¸.·´ (¸.·'* ☆
*/
#include <algorithm>
#include <cmath>
#include <cstring>
#include <iostream>
#include <map>
#include <numeric>
#include <random>
#include <stdio.h>
#include <string>
#include <unordered_map>
#include <vector>
#pragma GCC optimize("Ofast")
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep1(i, n) for (int i = 1; i < (n); ++i)
#define repr(i, n) for (int i = n; i >= 0; --i)
#define reprm(i, n) for (int i = n - 1; i >= 0; --i)
#define printynl(a) printf(a ? "yes\n" : "no\n")
#define printyn(a) printf(a ? "Yes\n" : "No\n")
#define printYN(a) printf(a ? "YES\n" : "NO\n")
#define printin(a) printf(a ? "possible\n" : "inposible\n")
#define printdb(a) printf("%.16f\n", a) //少数出力
#define all(x) (x).begin(), (x).end()
#define allsum(a, b, c) ((a + b) * c / 2) //等差数列の和、初項,末項,項数
using ll = long long;
const int INF = 2147483647;
const int MINF = -2147483648;
const ll LINF = ll(9223372036854775807);
const ll MOD = 1000000007;
const double PI = acos(-1);
//マクロとかここまで
using namespace std;
int ggd(int number1, int number2) { // ggcを求める
int m = number1;
int n = number2;
if (number2 > number1) {
m = number2;
n = number1;
}
while (m != n) {
int temp = n;
n = m - n;
m = temp;
}
return m;
}
int lcm(int number1, int number2) { // lcmを求める
return number1 * number2 / ggd(number1, number2);
}
bool is_prime(int64_t x) { //素数判定
for (int64_t i = 2; i * i <= x; i++) {
if (x % i == 0)
return false;
}
return true;
}
ll nearPow2(ll n) // x以上の2のべき乗を返す
{
// nが0以下の時は0とする。
if (n <= 0)
return 0;
// (n & (n - 1)) == 0 の時は、nが2の冪乗であるため、そのままnを返す。
if ((n & (n - 1)) == 0)
return ll(n);
// bitシフトを用いて、2の冪乗を求める。
ll ret = 1;
while (n > 0) {
ret <<= 1;
n >>= 1;
}
return ret;
}
map<int64_t, int> prime_factor(int64_t n) { //素因数分解
map<int64_t, int> ret;
for (int64_t i = 2; i * i <= n; i++) {
while (n % i == 0) {
ret[i]++;
n /= i;
}
}
if (n != 1)
ret[n] = 1;
return ret;
}
template <int mod> struct ModInt {
int x;
ModInt() : x(0) {}
ModInt(int64_t y) : x(y >= 0 ? y % mod : (mod - (-y) % mod) % mod) {}
ModInt &operator+=(const ModInt &p) {
if ((x += p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator-=(const ModInt &p) {
if ((x += mod - p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator*=(const ModInt &p) {
x = (int)(1LL * x * p.x % mod);
return *this;
}
ModInt &operator/=(const ModInt &p) {
*this *= p.inverse();
return *this;
}
ModInt operator-() const { return ModInt(-x); }
ModInt operator+(const ModInt &p) const { return ModInt(*this) += p; }
ModInt operator-(const ModInt &p) const { return ModInt(*this) -= p; }
ModInt operator*(const ModInt &p) const { return ModInt(*this) *= p; }
ModInt operator/(const ModInt &p) const { return ModInt(*this) /= p; }
bool operator==(const ModInt &p) const { return x == p.x; }
bool operator!=(const ModInt &p) const { return x != p.x; }
ModInt inverse() const {
int a = x, b = mod, u = 1, v = 0, t;
while (b > 0) {
t = a / b;
swap(a -= t * b, b);
swap(u -= t * v, v);
}
return ModInt(u);
}
ModInt pow(int64_t n) const {
ModInt ret(1), mul(x);
while (n > 0) {
if (n & 1)
ret *= mul;
mul *= mul;
n >>= 1;
}
return ret;
}
friend ostream &operator<<(ostream &os, const ModInt &p) { return os << p.x; }
friend istream &operator>>(istream &is, ModInt &a) {
int64_t t;
is >> t;
a = ModInt<mod>(t);
return (is);
}
static int get_mod() { return mod; }
};
using modint = ModInt<MOD>; // MOD=10億7
// mod. m での a の逆元 a^{-1} を計算する
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
// aCbを1000000007で割った余りを求める
ll aCb(ll a, ll b) {
ll ans = 1;
for (ll i = 0; i < b; i++) {
ans *= a - i;
ans %= MOD;
}
for (ll i = 1; i <= b; i++) {
ans *= modinv(i, MOD);
ans %= MOD;
}
return ans;
}
/*-----------------------------------------ここまでライブラリとか-----------------------------------------*/
int main() {
int n, k, step = 0;
ll cost = 0;
scanf("%d%d", &n, &k);
vector<int> h(n);
rep(i, n) scanf("%d", &h[i]);
vector<int> dp(n);
dp[0] = 0;
rep1(i, n) {
dp[i] = INF;
for (int j = 1; j <= k && i - j >= 0; ++j) {
dp[i] = min(dp[i], abs(h[i - j] - h[i]) + dp[i - j]);
}
}
printf("%d\n", dp[n - 1]);
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 960,388 | 960,389 | u917972976 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll n, k, temp;
cin >> n >> k;
ll arr[n];
ll res[n][k];
ll min[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
min[i] = 100005;
}
temp = abs(arr[1] - arr[0]);
for (int i = 0; i < k; i++) {
res[0][i] = 0;
res[1][i] = temp;
}
min[0] = 0;
min[1] = temp;
for (int i = 2; i < n; i++) {
for (int j = 1; j <= k; j++) {
if ((i - j) < 0)
break;
res[i][j - 1] = abs(arr[i] - arr[i - j]) + min[i - j];
if (res[i][j - 1] < min[i])
min[i] = res[i][j - 1];
}
}
cout << min[n - 1] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll n, k, temp;
cin >> n >> k;
ll arr[n];
ll res[n][k];
ll min[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
min[i] = 1e16 + 250;
}
temp = abs(arr[1] - arr[0]);
for (int i = 0; i < k; i++) {
res[0][i] = 0;
res[1][i] = temp;
}
min[0] = 0;
min[1] = temp;
for (int i = 2; i < n; i++) {
for (int j = 1; j <= k; j++) {
if ((i - j) < 0)
break;
res[i][j - 1] = abs(arr[i] - arr[i - j]) + min[i - j];
if (res[i][j - 1] < min[i])
min[i] = res[i][j - 1];
}
}
cout << min[n - 1] << endl;
return 0;
} | [
"literal.number.change",
"assignment.value.change",
"assignment.change"
] | 960,399 | 960,400 | u307699432 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
typedef vector<int> vi;
typedef vector<long long> vll;
typedef pair<int, int> pii;
typedef vector<pii> vii;
#define ll long long
#define ff first
#define ss second
#define pb push_back
#define mkp make_pair
#define sz size()
#define forf(a, b, c) for (int i = a; i <= b; i += c)
#define forr(a, b, c) for (int i = a; i >= b; i -= c)
#define all(a) a.begin(), a.end()
#define mem(a, b) memset(a, b, sizeof(a))
#define pi 2 * acos(0.0)
#define End return 0;
#define nl endl
#define scan1(a) scanf("%d", &a)
#define scan2(a, b) scanf("%d %d", &a, &b)
#define scan3(a, b, c) scanf("%d %d %d", &a, &b, &c)
#define scanl(a) scanf("%lld", &a)
#define scanll(a, b) scanf("%lld %lld", &a, &b)
#define scanlll(a, b, c) scanf("%lld %lld %lld", &a, &b, &c)
#define print1(a) printf("%d", a)
#define print2(a, b) printf("%d %d", a, b)
#define print3(a, b, c) printf("%d %d %d", a, b, c)
#define printl(a) printf("%lld", a)
#define printll(a, b) printf("%lld %lld", a, b)
#define printlll(a, b, c) printf("%lld %lld %lld", a, b, c)
#define MAXN 100000007
#define INF 0x3f3f3f3f
vi prime;
// void seive(ll N){for(int i=2;i<=N;i++){if(mark[i]==false){prime.pb(i);for(int
// j=i+i;j<N;j+=i)mark[j]=true;}}} freopen("input.txt", "r", stdin);
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
vll v(n + 3), vv(n + 3);
for (int i = 1; i <= n; i++)
cin >> v[i];
for (int i = 1; i <= k && i <= n; i++)
vv[i] = abs(v[1] - v[i]);
for (int i = k + 1; i <= n; i++)
vv[i] = 1000000000;
for (int i = 3; i <= n; i++) {
int kk = k, ii = 1;
// cout<<"i "<<i<<endl;
while (kk && ii < i) {
// if(i==5) cout<<"ii "<<ii<<endl;
vv[i] = min(vv[i - ii] + abs(v[i] - v[i - ii]), vv[i]);
kk--;
ii++;
}
}
// for(int i=1;i<=n;i++) cout<<vv[i]<< " ";
cout << vv[n] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef vector<int> vi;
typedef vector<long long> vll;
typedef pair<int, int> pii;
typedef vector<pii> vii;
#define ll long long
#define ff first
#define ss second
#define pb push_back
#define mkp make_pair
#define sz size()
#define forf(a, b, c) for (int i = a; i <= b; i += c)
#define forr(a, b, c) for (int i = a; i >= b; i -= c)
#define all(a) a.begin(), a.end()
#define mem(a, b) memset(a, b, sizeof(a))
#define pi 2 * acos(0.0)
#define End return 0;
#define nl endl
#define scan1(a) scanf("%d", &a)
#define scan2(a, b) scanf("%d %d", &a, &b)
#define scan3(a, b, c) scanf("%d %d %d", &a, &b, &c)
#define scanl(a) scanf("%lld", &a)
#define scanll(a, b) scanf("%lld %lld", &a, &b)
#define scanlll(a, b, c) scanf("%lld %lld %lld", &a, &b, &c)
#define print1(a) printf("%d", a)
#define print2(a, b) printf("%d %d", a, b)
#define print3(a, b, c) printf("%d %d %d", a, b, c)
#define printl(a) printf("%lld", a)
#define printll(a, b) printf("%lld %lld", a, b)
#define printlll(a, b, c) printf("%lld %lld %lld", a, b, c)
#define MAXN 100000007
#define INF 0x3f3f3f3f
vi prime;
// void seive(ll N){for(int i=2;i<=N;i++){if(mark[i]==false){prime.pb(i);for(int
// j=i+i;j<N;j+=i)mark[j]=true;}}} freopen("input.txt", "r", stdin);
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
vll v(n + 3), vv(n + 3);
for (int i = 1; i <= n; i++)
cin >> v[i];
for (int i = 1; i <= k && i <= n; i++)
vv[i] = abs(v[1] - v[i]);
for (int i = k + 1; i <= n; i++)
vv[i] = 1000000000;
for (int i = k + 1; i <= n; i++) {
int kk = k, ii = 1;
// cout<<"i "<<i<<endl;
while (kk && ii < i) {
// if(i==5) cout<<"ii "<<ii<<endl;
vv[i] = min(vv[i - ii] + abs(v[i] - v[i - ii]), vv[i]);
kk--;
ii++;
}
}
// for(int i=1;i<=n;i++) cout<<vv[i]<< " ";
cout << vv[n] << endl;
return 0;
}
| [
"identifier.replace.add",
"literal.replace.remove",
"control_flow.loop.for.initializer.change"
] | 960,401 | 960,402 | u615763347 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 1;
int n, k, arr[N], dp[N];
int calc(int idx) {
if (idx == n - 1)
return 0;
if (idx > n - 1)
return 1e5;
if (dp[idx] != -1)
return dp[idx];
int mn = 1e5;
for (int i = idx + 1; i <= idx + k && i < n; ++i)
mn = min(mn, abs(arr[idx] - arr[i]) + calc(i));
return dp[idx] = mn;
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; ++i)
cin >> arr[i];
memset(dp, -1, sizeof(dp));
cout << calc(0);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 1;
int n, k, arr[N], dp[N];
int calc(int idx) {
if (idx == n - 1)
return 0;
if (idx > n - 1)
return 1e5;
if (dp[idx] != -1)
return dp[idx];
int mn = 1e9 + 10;
for (int i = idx + 1; i <= idx + k && i < n; ++i)
mn = min(mn, abs(arr[idx] - arr[i]) + calc(i));
return dp[idx] = mn;
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; ++i)
cin >> arr[i];
memset(dp, -1, sizeof(dp));
cout << calc(0);
return 0;
} | [
"literal.number.change"
] | 960,409 | 960,410 | u399756885 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.