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 <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <string>
using namespace std;
int main() {
int N, K, arr[100000], dp[100000];
cin >> N >> K;
for (int i = 0; i < N; i++) {
cin >> arr[i];
dp[i] = 1000000001;
}
dp[0] = 0;
int i, j;
for (i = 0; i < N; i++) {
for (j = i + 1; j < i + K; j++) {
if (j < N) {
dp[j] = min(dp[j], dp[i] + abs(arr[i] - arr[j]));
}
}
}
cout << dp[N - 1];
return 0;
} | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <string>
using namespace std;
int main() {
int N, K, arr[100000], dp[100000];
cin >> N >> K;
for (int i = 0; i < N; i++) {
cin >> arr[i];
dp[i] = 1000000001;
}
dp[0] = 0;
int i, j;
for (i = 0; i < N; i++) {
for (j = i + 1; j < i + K + 1; j++) {
if (j < N) {
dp[j] = min(dp[j], dp[i] + abs(arr[i] - arr[j]));
}
}
}
cout << dp[N - 1];
return 0;
} | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 959,364 | 959,365 | u069035199 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define faster ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL)
#define cint \
int t; \
cin >> t; \
while (t--)
#define rep(i, a, b) for (int i = a; i < b; i++)
#define vint vector<int>
#define all(v) (v).begin(), (v).end()
#define pii pair<int, int>
#define pb push_back
const int N = 1e5 + 5;
int mod = 1e9 + 7;
int cache[N];
int a[N];
int n, k;
int dp(int idx) {
// if(idx<0) return 1e10;
if (idx == 1)
return 0;
int &ans = cache[idx];
if (ans != -1)
return ans;
ans = 1e10;
for (int i = idx - 1; i >= 0 && i >= idx - k; i--) {
ans = min(ans, dp(i) + abs(a[idx] - a[i]));
}
return ans;
}
int32_t main() {
faster;
// int n,k;
cin >> n >> k;
memset(cache, -1, sizeof(cache));
// int h[n];
for (int i = 1; i <= n; i++)
cin >> a[i];
cout << dp(n - 1) << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define faster ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL)
#define cint \
int t; \
cin >> t; \
while (t--)
#define rep(i, a, b) for (int i = a; i < b; i++)
#define vint vector<int>
#define all(v) (v).begin(), (v).end()
#define pii pair<int, int>
#define pb push_back
const int N = 1e5 + 5;
int mod = 1e9 + 7;
int cache[N];
int a[N];
int n, k;
int dp(int idx) {
// if(idx<0) return 1e10;
if (idx == 1)
return 0;
int &ans = cache[idx];
if (ans != -1)
return ans;
ans = 1e10;
for (int i = idx - 1; i >= 0 && i >= idx - k; i--) {
ans = min(ans, dp(i) + abs(a[idx] - a[i]));
}
return ans;
}
int32_t main() {
faster;
// int n,k;
cin >> n >> k;
memset(cache, -1, sizeof(cache));
// int h[n];
for (int i = 1; i <= n; i++)
cin >> a[i];
cout << dp(n) << endl;
} | [
"expression.operation.binary.remove"
] | 959,366 | 959,367 | u254775795 | cpp |
p03161 | #include <bits/stdc++.h>
#define F first
#define S second
#define ld long douroote
#define pb push_back
#define ll long long
#define INF 0x7f7f7f7f
#define sc(a) scanf("%d", &a)
#define scll(a) scanf("%I64d", &a)
#define scc(a) scanf(" %c", &a)
#define scs(a) scanf(" %s", a)
#define me(a, b) memset(a, b, sizeof a)
#define all(a) a.begin(), a.end()
#define allr(a, n) a, a + n
#define loop(a, s, e) for (ll a = s; a <= e; a++)
#define read_arr(a, s, n) \
for (ll i = s; i < n + s; i++) { \
sc(a[i]); \
}
#define read_arr_ll(a, s, n) \
for (ll i = s; i < n + s; i++) { \
scll(a[i]); \
}
#define open(in, out) \
freopen(in, "r", stdin); \
freopen(out, "w", stdout);
#define err(a, s) cerr << a << s;
#define err_arr(a, s, n) \
for (ll i = s; i < n + s; i++) { \
cerr << a[i] << " "; \
} \
cerr << endl;
#define prtll(x) printf("%lld", x);
#define prt(x) printf("%d", x);
using namespace std;
const int N = 1e5 + 10;
ll mem[N], n, a[N], k;
int main() {
scll(n);
scll(k);
read_arr(a, 1, n);
mem[n] = 0;
for (int i = n - 2; i >= 1; i--) {
ll ans = 1e18;
for (int j = 1; j <= k && j + i <= n; j++) {
ans = min(abs(a[i] - a[i + j]) + mem[i + j], ans);
}
mem[i] = ans;
}
// err_arr(mem,1,n);
printf("%lld\n", mem[1]);
}
/**
n=0
n-1=20
n-2= 20 , 10
n-3=
**/
| #include <bits/stdc++.h>
#define F first
#define S second
#define ld long douroote
#define pb push_back
#define ll long long
#define INF 0x7f7f7f7f
#define sc(a) scanf("%d", &a)
#define scll(a) scanf("%I64d", &a)
#define scc(a) scanf(" %c", &a)
#define scs(a) scanf(" %s", a)
#define me(a, b) memset(a, b, sizeof a)
#define all(a) a.begin(), a.end()
#define allr(a, n) a, a + n
#define loop(a, s, e) for (ll a = s; a <= e; a++)
#define read_arr(a, s, n) \
for (ll i = s; i < n + s; i++) { \
sc(a[i]); \
}
#define read_arr_ll(a, s, n) \
for (ll i = s; i < n + s; i++) { \
scll(a[i]); \
}
#define open(in, out) \
freopen(in, "r", stdin); \
freopen(out, "w", stdout);
#define err(a, s) cerr << a << s;
#define err_arr(a, s, n) \
for (ll i = s; i < n + s; i++) { \
cerr << a[i] << " "; \
} \
cerr << endl;
#define prtll(x) printf("%lld", x);
#define prt(x) printf("%d", x);
using namespace std;
const int N = 1e5 + 10;
ll mem[N], n, a[N], k;
int main() {
scll(n);
scll(k);
read_arr(a, 1, n);
mem[n] = 0;
for (int i = n - 1; i >= 1; i--) {
ll ans = 1e18;
for (int j = 1; j <= k && j + i <= n; j++) {
ans = min(abs(a[i] - a[i + j]) + mem[i + j], ans);
}
mem[i] = ans;
}
// err_arr(mem,1,n);
printf("%lld\n", mem[1]);
}
/**
n=0
n-1=20
n-2= 20 , 10
n-3=
**/
| [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 959,368 | 959,369 | u881144265 | cpp |
p03161 | #include <algorithm>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stdio.h>
#include <string>
#define ll long long
using namespace std;
ll factorial(ll n) {
if (n == 1 || n == 0)
return 1;
return n * factorial(n - 1);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
cin >> n >> k;
int arr[n];
for (int i = 0; i < n; i++)
cin >> arr[i];
int dp[n];
dp[0] = 0;
for (int i = 1; i < n; i++) {
dp[i] = 10e4 + 1;
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];
return 0;
}
| #include <algorithm>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stdio.h>
#include <string>
#define ll long long
using namespace std;
ll factorial(ll n) {
if (n == 1 || n == 0)
return 1;
return n * factorial(n - 1);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
cin >> n >> k;
int arr[n];
for (int i = 0; i < n; i++)
cin >> arr[i];
int dp[n];
dp[0] = 0;
for (int i = 1; i < n; i++) {
dp[i] = 10e8 + 1051;
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];
return 0;
}
| [
"literal.number.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 959,370 | 959,371 | u477542712 | cpp |
p03161 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int h[n];
vector<int> cost(n, 100000);
for (int i = 0; i < n; ++i)
cin >> h[i];
cost[0] = 0;
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j <= i + k; ++j) {
if (j < n) {
cost[j] = min(cost[j], cost[i] + abs(h[i] - h[j]));
}
}
}
cout << cost[n - 1] << endl;
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int h[n];
vector<int> cost(n, INT32_MAX);
for (int i = 0; i < n; ++i)
cin >> h[i];
cost[0] = 0;
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j <= i + k; ++j) {
if (j < n) {
cost[j] = min(cost[j], cost[i] + abs(h[i] - h[j]));
}
}
}
cout << cost[n - 1] << "\n";
return 0;
} | [
"call.arguments.change",
"io.output.change"
] | 959,376 | 959,377 | u124430580 | cpp |
p03161 | #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
const int N = 1e5 + 200;
const ll inf = 1e14;
int n, k;
ll a[N], mem[N];
ll dp(int i) {
if (i == n - 1)
return 0;
if (i >= n)
return inf;
ll &ret = mem[i];
if (ret != -1)
return ret;
ret = inf;
for (int j = 1; j <= k; j++)
ret = min(ret, abs(a[i] - a[i + k]) + dp(i + k));
return ret;
}
int main() {
memset(mem, -1, sizeof mem);
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++)
scanf("%lld", a + i);
printf("%lld", dp(0));
}
| #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
const int N = 1e5 + 200;
const ll inf = 1e14;
int n, k;
ll a[N], mem[N];
ll dp(int i) {
if (i == n - 1)
return 0;
if (i >= n)
return inf;
ll &ret = mem[i];
if (ret != -1)
return ret;
ret = inf;
for (int j = 1; j <= k; j++)
ret = min(ret, abs(a[i] - a[i + j]) + dp(i + j));
return ret;
}
int main() {
memset(mem, -1, sizeof mem);
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++)
scanf("%lld", a + i);
printf("%lld", dp(0));
}
| [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 959,378 | 959,379 | u130912106 | cpp |
p03161 | #include <algorithm>
#include <bits/stdc++.h>
#include <iostream>
#include <math.h>
#define ll long long int
#define pb push_back
#define fi first
#define se second
#define N 100005
#define inf 1e18
using namespace std;
ll binomialCoeff(ll n, ll k);
ll power(ll x, ll y);
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int mod(int a, int b) {
if (a > b)
return a - b;
return b - a;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
int n, k;
cin >> n >> k;
int dp[N];
int h[n + 1];
for (int i = 1; i <= n; i++)
cin >> h[i];
for (int i = 1; i <= n; i++)
dp[i] = N;
dp[1] = 0;
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= k; j++) {
if (i - j <= 0)
break;
dp[i] = min(dp[i], dp[i - j] + mod(h[i], h[i - j]));
}
}
cout << dp[n];
}
ll binomialCoeff(ll n, ll k) {
ll res = 1;
if (k > n - k)
k = n - k;
for (int i = 0; i < k; ++i) {
res *= (n - i);
res /= (i + 1);
}
return res;
}
ll power(ll x, ll y) {
ll temp;
if (y == 0)
return 1;
temp = power(x, y / 2);
if (y % 2 == 0)
return temp * temp;
else
return x * temp * temp;
}
| #include <algorithm>
#include <bits/stdc++.h>
#include <iostream>
#include <math.h>
#define ll long long int
#define pb push_back
#define fi first
#define se second
#define N 100005
#define inf 1e18
using namespace std;
ll binomialCoeff(ll n, ll k);
ll power(ll x, ll y);
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int mod(int a, int b) {
if (a > b)
return a - b;
return b - a;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
int n, k;
cin >> n >> k;
ll dp[N];
int h[n + 1];
for (int i = 1; i <= n; i++)
cin >> h[i];
for (int i = 1; i <= n; i++)
dp[i] = inf;
dp[1] = 0;
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= k; j++) {
if (i - j <= 0)
break;
dp[i] = min(dp[i], dp[i - j] + mod(h[i], h[i - j]));
}
}
cout << dp[n];
}
ll binomialCoeff(ll n, ll k) {
ll res = 1;
if (k > n - k)
k = n - k;
for (int i = 0; i < k; ++i) {
res *= (n - i);
res /= (i + 1);
}
return res;
}
ll power(ll x, ll y) {
ll temp;
if (y == 0)
return 1;
temp = power(x, y / 2);
if (y % 2 == 0)
return temp * temp;
else
return x * temp * temp;
}
| [
"variable_declaration.type.change",
"assignment.value.change",
"identifier.change"
] | 959,380 | 959,381 | u304472566 | cpp |
p03161 | #include <iostream>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[n], dp[n] = {};
for (int i = 0; i < n; i++)
cin >> a[i];
for (int i = 1; i < n; i++) {
dp[i] = 1e5;
for (int j = i - 1; j >= max(i - k, 0); j--)
dp[i] = min(dp[i], dp[j] + abs(a[i] - a[j]));
}
cout << dp[n - 1];
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[n], dp[n] = {};
for (int i = 0; i < n; i++)
cin >> a[i];
for (int i = 1; i < n; i++) {
dp[i] = 1e9;
for (int j = i - 1; j >= max(i - k, 0); j--)
dp[i] = min(dp[i], dp[j] + abs(a[i] - a[j]));
}
cout << dp[n - 1];
return 0;
}
| [
"literal.number.change",
"assignment.value.change"
] | 959,382 | 959,383 | u851831516 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k;
cin >> n >> k;
long long int a[n + 1] = {0};
for (int i = 1; i <= n; i++)
cin >> a[i];
long long int dp[n + 2] = {0};
int i = 0, j = 0, q = 0;
for (int i = 2; i <= n; i++) {
long long int mi = 1000000000;
for (j = 1; j <= k, i - j > 0; j++) {
mi = min(mi, abs(a[i] - a[i - j]) + dp[i - j]);
}
dp[i] = mi;
}
cout << dp[n];
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k;
cin >> n >> k;
long long int a[n + 1] = {0};
for (int i = 1; i <= n; i++)
cin >> a[i];
long long int dp[n + 2] = {0};
int i = 0, j = 0, q = 0;
for (int i = 2; i <= n; i++) {
long long int mi = 1000000000;
for (j = 1; j <= k && i - j > 0; j++) {
mi = min(mi, abs(a[i] - a[i - j]) + dp[i - j]);
}
dp[i] = mi;
}
cout << dp[n];
return 0;
}
| [
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 959,384 | 959,385 | u452579095 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
int n, k;
const int N = 1e5 + 5;
const int INF = 1e8;
int mem[N];
int h[N];
int frog(int i) {
if (i == n - 1)
return 0;
if (mem[i] != -1)
return mem[i];
int ans = INF;
for (int j = 1; j <= k; j++) {
if (i + k < n)
ans = min(ans, abs(h[i] - h[i + j]) + frog(i + j));
}
mem[i] = ans;
return mem[i];
}
int main() {
scanf("%d %d", &n, &k);
memset(mem, -1, sizeof mem);
for (int i = 0; i < n; i++)
scanf("%d", &h[i]);
printf("%d\n", frog(0));
return EXIT_SUCCESS;
}
| #include <bits/stdc++.h>
using namespace std;
int n, k;
const int N = 1e5 + 5;
const int INF = 2e9;
int mem[N];
int h[N];
int frog(int i) {
if (i == n - 1)
return 0;
if (mem[i] != -1)
return mem[i];
int ans = INF;
for (int j = 1; j <= k; j++) {
if (i + j < n)
ans = min(ans, abs(h[i] - h[i + j]) + frog(i + j));
}
mem[i] = ans;
return mem[i];
}
int main() {
scanf("%d %d", &n, &k);
memset(mem, -1, sizeof mem);
for (int i = 0; i < n; i++)
scanf("%d", &h[i]);
printf("%d\n", frog(0));
return EXIT_SUCCESS;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"identifier.change",
"control_flow.branch.if.condition.change"
] | 959,388 | 959,387 | u452706738 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
#define int long long
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int dp[100010], h[100010];
int INF = 1LL << 60;
signed main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++)
cin >> h[i];
for (int i = 0; i < 100010; i++)
dp[i] = INF;
dp[0] = 0;
for (int i = 1; i < n; i++) {
for (int j = 1; j <= k; j++) {
if (i - k >= 0)
chmin(dp[i], dp[i - j] + abs(h[i - j] - h[i]));
}
}
cout << dp[n - 1] << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int dp[100010], h[100010];
int INF = 1LL << 60;
signed main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++)
cin >> h[i];
for (int i = 0; i < 100010; i++)
dp[i] = INF;
dp[0] = 0;
for (int i = 1; i < n; i++) {
for (int j = 1; j <= k; j++) {
if (i - j >= 0)
chmin(dp[i], dp[i - j] + abs(h[i - j] - h[i]));
}
}
cout << dp[n - 1] << endl;
} | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 959,389 | 959,390 | u962609087 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
#define int long long
const int INF = 1LL << 60;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int dp[100001];
int h[100001];
signed main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> h[i];
}
for (int i = 0; i < 100001; i++) {
dp[i] == INF;
}
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= k; j++) {
chmin(dp[i + j], dp[i] + abs(h[i] - h[i + j]));
}
}
cout << dp[n - 1] << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
const int INF = 1LL << 60;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int dp[100001];
int h[100001];
signed main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> h[i];
}
for (int i = 0; i < 100001; i++) {
dp[i] = INF;
}
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= k; j++) {
chmin(dp[i + j], dp[i] + abs(h[i] - h[i + j]));
}
}
cout << dp[n - 1] << endl;
}
| [
"expression.operation.compare.replace.remove",
"assignment.replace.add",
"misc.typo"
] | 959,391 | 959,392 | u962609087 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define INF 1LL << 60
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int dp[100001];
int h[100001];
signed main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> h[i];
}
for (int i = 0; i < 100001; i++) {
dp[i] == INF;
}
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= k; j++) {
chmin(dp[i + j], dp[i] + abs(h[i] - h[i + j]));
}
}
cout << dp[n - 1] << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
const int INF = 1LL << 60;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int dp[100001];
int h[100001];
signed main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> h[i];
}
for (int i = 0; i < 100001; i++) {
dp[i] = INF;
}
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= k; j++) {
chmin(dp[i + j], dp[i] + abs(h[i] - h[i + j]));
}
}
cout << dp[n - 1] << endl;
}
| [
"expression.operation.compare.replace.remove",
"assignment.replace.add",
"misc.typo"
] | 959,393 | 959,392 | u962609087 | cpp |
p03161 | #include <bits/stdc++.h>
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned short int us;
#define forn(i, n) for (int i = 0; i < int(n); ++i)
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
cout << fixed << setprecision(15);
int n, k;
cin >> n >> k;
vector<int> h(n);
for (int i = 0; i < n; ++i)
cin >> h[i];
vector<int> a(n, INT_MAX);
a[0] = 0;
for (int i = 1; i < n; ++i) {
for (int j = max(0, i - k); j < i - 1; ++j)
a[i] = min(a[i], a[j] + abs(h[j] - h[i]));
}
cout << a[n - 1];
}
| #include <bits/stdc++.h>
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned short int us;
#define forn(i, n) for (int i = 0; i < int(n); ++i)
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
cout << fixed << setprecision(15);
int n, k;
cin >> n >> k;
vector<int> h(n);
for (int i = 0; i < n; ++i)
cin >> h[i];
vector<int> a(n, INT_MAX);
a[0] = 0;
for (int i = 1; i < n; ++i) {
for (int j = max(0, i - k); j < i; ++j)
a[i] = min(a[i], a[j] + abs(h[j] - h[i]));
}
cout << a[n - 1];
}
| [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 959,394 | 959,395 | u179838120 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(v) v.begin(), v.end()
#define _GLIBCXX_DEBUG
int main() {
int n, k;
cin >> n >> k;
long long dp[n + 100];
int h[n + 100];
rep(i, n) { cin >> h[i + 1]; }
dp[1] = 0;
long long cost;
for (int i = 2; i < n + 1; i++) {
cost = 100000;
for (int j = 1; j < min(k + 1, i); j++) {
cost = min(cost, dp[i - j] + abs(h[i - j] - h[i]));
}
dp[i] = cost;
}
cout << dp[n] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(v) v.begin(), v.end()
#define _GLIBCXX_DEBUG
int main() {
int n, k;
cin >> n >> k;
long long dp[n + 100];
int h[n + 100];
rep(i, n) { cin >> h[i + 1]; }
dp[1] = 0;
long long cost;
for (int i = 2; i < n + 1; i++) {
cost = 1000000000;
for (int j = 1; j < min(k + 1, i); j++) {
cost = min(cost, dp[i - j] + abs(h[i - j] - h[i]));
}
dp[i] = cost;
}
cout << dp[n] << endl;
return 0;
} | [
"literal.number.change",
"assignment.value.change"
] | 959,405 | 959,404 | u518042385 | cpp |
p03161 | #include "bits/stdc++.h"
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, a, b) for (int i = (b)-1; i >= (a); --i)
#define ALL(v) v.begin(), v.end()
#define FS first
#define SC second
#define SZ(a) int((a).size())
#define SORT(c) sort((c).begin(), (c).end())
#define MEMSET(v, h) memset((v), h, sizeof(v))
#define SQR(x) ((x) * (x))
#define BIT(n) (1LL << (n))
#define PCNT(x) __builtin_popcountll(x)
#define PB push_back
#define MP make_pair
#define endl "\n"
using namespace std;
typedef long long LL;
typedef long double LD;
typedef vector<int> VI;
typedef vector<LL> VLL;
typedef vector<bool> VB;
typedef vector<vector<int>> VVI;
typedef vector<vector<bool>> VVB;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef vector<PII> VPII;
const LL MOD = 1000000007ll;
const LL INF = 2000000000ll;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
long power(long a, long b) {
return b ? power(a * a % MOD, b / 2) * (b % 2 ? a : 1) % MOD : 1;
}
long perm(int N, int K) {
long x = 1;
for (int i = 1; i <= K; i++) {
x = x * (N - i + 1) % MOD;
}
return x % MOD;
}
long factorial(int N) { return perm(N, N); }
long comb(int N, int K) {
long x = 1, y = 1;
for (int i = 1; i <= K; i++) {
x = x * (N - i + 1) % MOD;
y = y * i % MOD;
}
return x * power(y, MOD - 2) % MOD;
}
long hcomb(int N, int K) { return comb(N + K - 1, N - 1); }
int dtoi(double d) {
if ((double)2 * d - floor(d) - ceil(d) >= 0)
return ceil(d);
else
return floor(d);
}
bool isprime(int n) {
if (n < 2)
return false;
for (int i = 2; i * i <= n; ++i) {
if (n % i == 0)
return false;
}
return true;
}
void eratosthenes(int n) {
// エラトステネスのふるい
bitset<1000000> is_prime(0); // 十分大きなサイズを確保します
for (int i = 2; i <= n; ++i)
is_prime.set(i); // とりあえず全部ふるいに入れます
for (int i = 2; i <= n; ++i) {
if (is_prime[i]) { // 素数 i を発見したら
for (int j = i * 2; j <= n; j += i) {
is_prime.reset(j); // i の倍数をふるい落とす
}
}
}
for (int i = 2; i <= n; ++i) {
if (is_prime[i])
cout << i << endl;
}
}
void dfs(const vector<vector<int>> &G, int v, vector<int> &seen) {
seen[v] = true; // v を訪問済にする
// v から行ける各頂点 next_v について
for (int next_v : G[v]) {
if (seen[next_v])
continue; // next_v が探索済だったらスルー
dfs(G, next_v, seen); // 再帰的に探索
}
}
void bfs(const vector<vector<int>> &G, int v, vector<int> &dist) {
REP(i, SZ(dist)) dist[i] = -1; // 全頂点を「未訪問」に初期化
queue<int> que;
// 初期条件 (頂点 0 を初期ノードとする)
dist[v] = 0;
que.push(v); // 0 を橙色頂点にする
// BFS 開始 (キューが空になるまで探索を行う)
while (!que.empty()) {
v = que.front(); // キューから先頭頂点を取り出す
que.pop();
// v から辿れる頂点をすべて調べる
for (int next_v : G[v]) {
if (dist[next_v] != -1)
continue; // すでに発見済みの頂点は探索しない
// 新たな白色頂点 nv について距離情報を更新してキューに追加する
dist[next_v] = dist[v] + 1;
que.push(next_v);
}
}
}
int knapsack01(int N, int W, vector<int> &value, vector<int> &weight) {
VVI dp(N + 1, VI(W + 1, 0));
REP(i, N) REP(j, W + 1) {
if (j - weight[i] >= 0)
dp[i + 1][j] = max(dp[i][j - weight[i]] + value[i], dp[i][j]);
else
dp[i + 1][j] = dp[i][j];
}
return dp[N][W];
}
int knapsack01_reuse(int N, int W, vector<int> &value, vector<int> &weight) {
VI dp(W + 1, 0);
dp[0] = 0;
for (int i = 0; i < N; i++) {
for (int j = W; j > 0; j--) {
if (j - weight[i] >= 0)
dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
}
}
return dp[W];
}
int knapsack(int N, int W, vector<int> &value, vector<int> &weight) {
VVI dp(N + 1, VI(W + 1, 0));
REP(i, N) REP(j, W + 1) {
dp[i + 1][j] = max(dp[i][j], dp[i + 1][j]);
if (j - weight[i] >= 0)
dp[i + 1][j] = max(dp[i + 1][j - weight[i]] + value[i], dp[i + 1][j]);
}
return dp[N][W];
}
int knapsack_reuse(int N, int W, vector<int> &value, vector<int> &weight) {
VI dp(W + 1, 0);
dp[0] = 0;
for (int i = 0; i < N; ++i) {
for (int w = weight[i]; w <= W; ++w) {
dp[w] = max(dp[w], dp[w - weight[i]] + value[i]);
}
}
return dp[W];
}
int lis(int n, vector<int> &A) {
vector<int> L(n + 1, 0);
L[0] = A[0];
int length = 1;
FOR(i, 1, n) {
if (L[length - 1] < A[i])
L[length++] = A[i];
else
*lower_bound(L.begin(), next(L.begin(), length), A[i]) = A[i];
}
return length;
}
int lcs(string X, string Y) {
int m = X.length();
int n = Y.length();
int res = 0;
X = ' ' + X;
Y = ' ' + Y;
VVI c(m + 1, VI(n + 1, 0));
FOR(i, 1, m + 1) FOR(j, 1, n + 1) {
if (X[i] == Y[j])
c[i][j] = c[i - 1][j - 1] + 1;
else
c[i][j] = max(c[i - 1][j], c[i][j - 1]);
res = max(res, c[i][j]);
}
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(10);
int N, K;
cin >> N >> K;
VI h(N);
REP(i, N) cin >> h[i];
VI dp(N, INF);
dp[0] = 0;
REP(i, N - 1) {
REP(j, min(K + 1, N)) {
if (i + j <= N - 1)
chmin(dp[i + j], dp[i] + abs(h[i] - h[j]));
}
}
cout << dp[N - 1] << endl;
} | #include "bits/stdc++.h"
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, a, b) for (int i = (b)-1; i >= (a); --i)
#define ALL(v) v.begin(), v.end()
#define FS first
#define SC second
#define SZ(a) int((a).size())
#define SORT(c) sort((c).begin(), (c).end())
#define MEMSET(v, h) memset((v), h, sizeof(v))
#define SQR(x) ((x) * (x))
#define BIT(n) (1LL << (n))
#define PCNT(x) __builtin_popcountll(x)
#define PB push_back
#define MP make_pair
#define endl "\n"
using namespace std;
typedef long long LL;
typedef long double LD;
typedef vector<int> VI;
typedef vector<LL> VLL;
typedef vector<bool> VB;
typedef vector<vector<int>> VVI;
typedef vector<vector<bool>> VVB;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef vector<PII> VPII;
const LL MOD = 1000000007ll;
const LL INF = 2000000000ll;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
long power(long a, long b) {
return b ? power(a * a % MOD, b / 2) * (b % 2 ? a : 1) % MOD : 1;
}
long perm(int N, int K) {
long x = 1;
for (int i = 1; i <= K; i++) {
x = x * (N - i + 1) % MOD;
}
return x % MOD;
}
long factorial(int N) { return perm(N, N); }
long comb(int N, int K) {
long x = 1, y = 1;
for (int i = 1; i <= K; i++) {
x = x * (N - i + 1) % MOD;
y = y * i % MOD;
}
return x * power(y, MOD - 2) % MOD;
}
long hcomb(int N, int K) { return comb(N + K - 1, N - 1); }
int dtoi(double d) {
if ((double)2 * d - floor(d) - ceil(d) >= 0)
return ceil(d);
else
return floor(d);
}
bool isprime(int n) {
if (n < 2)
return false;
for (int i = 2; i * i <= n; ++i) {
if (n % i == 0)
return false;
}
return true;
}
void eratosthenes(int n) {
// エラトステネスのふるい
bitset<1000000> is_prime(0); // 十分大きなサイズを確保します
for (int i = 2; i <= n; ++i)
is_prime.set(i); // とりあえず全部ふるいに入れます
for (int i = 2; i <= n; ++i) {
if (is_prime[i]) { // 素数 i を発見したら
for (int j = i * 2; j <= n; j += i) {
is_prime.reset(j); // i の倍数をふるい落とす
}
}
}
for (int i = 2; i <= n; ++i) {
if (is_prime[i])
cout << i << endl;
}
}
void dfs(const vector<vector<int>> &G, int v, vector<int> &seen) {
seen[v] = true; // v を訪問済にする
// v から行ける各頂点 next_v について
for (int next_v : G[v]) {
if (seen[next_v])
continue; // next_v が探索済だったらスルー
dfs(G, next_v, seen); // 再帰的に探索
}
}
void bfs(const vector<vector<int>> &G, int v, vector<int> &dist) {
REP(i, SZ(dist)) dist[i] = -1; // 全頂点を「未訪問」に初期化
queue<int> que;
// 初期条件 (頂点 0 を初期ノードとする)
dist[v] = 0;
que.push(v); // 0 を橙色頂点にする
// BFS 開始 (キューが空になるまで探索を行う)
while (!que.empty()) {
v = que.front(); // キューから先頭頂点を取り出す
que.pop();
// v から辿れる頂点をすべて調べる
for (int next_v : G[v]) {
if (dist[next_v] != -1)
continue; // すでに発見済みの頂点は探索しない
// 新たな白色頂点 nv について距離情報を更新してキューに追加する
dist[next_v] = dist[v] + 1;
que.push(next_v);
}
}
}
int knapsack01(int N, int W, vector<int> &value, vector<int> &weight) {
VVI dp(N + 1, VI(W + 1, 0));
REP(i, N) REP(j, W + 1) {
if (j - weight[i] >= 0)
dp[i + 1][j] = max(dp[i][j - weight[i]] + value[i], dp[i][j]);
else
dp[i + 1][j] = dp[i][j];
}
return dp[N][W];
}
int knapsack01_reuse(int N, int W, vector<int> &value, vector<int> &weight) {
VI dp(W + 1, 0);
dp[0] = 0;
for (int i = 0; i < N; i++) {
for (int j = W; j > 0; j--) {
if (j - weight[i] >= 0)
dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
}
}
return dp[W];
}
int knapsack(int N, int W, vector<int> &value, vector<int> &weight) {
VVI dp(N + 1, VI(W + 1, 0));
REP(i, N) REP(j, W + 1) {
dp[i + 1][j] = max(dp[i][j], dp[i + 1][j]);
if (j - weight[i] >= 0)
dp[i + 1][j] = max(dp[i + 1][j - weight[i]] + value[i], dp[i + 1][j]);
}
return dp[N][W];
}
int knapsack_reuse(int N, int W, vector<int> &value, vector<int> &weight) {
VI dp(W + 1, 0);
dp[0] = 0;
for (int i = 0; i < N; ++i) {
for (int w = weight[i]; w <= W; ++w) {
dp[w] = max(dp[w], dp[w - weight[i]] + value[i]);
}
}
return dp[W];
}
int lis(int n, vector<int> &A) {
vector<int> L(n + 1, 0);
L[0] = A[0];
int length = 1;
FOR(i, 1, n) {
if (L[length - 1] < A[i])
L[length++] = A[i];
else
*lower_bound(L.begin(), next(L.begin(), length), A[i]) = A[i];
}
return length;
}
int lcs(string X, string Y) {
int m = X.length();
int n = Y.length();
int res = 0;
X = ' ' + X;
Y = ' ' + Y;
VVI c(m + 1, VI(n + 1, 0));
FOR(i, 1, m + 1) FOR(j, 1, n + 1) {
if (X[i] == Y[j])
c[i][j] = c[i - 1][j - 1] + 1;
else
c[i][j] = max(c[i - 1][j], c[i][j - 1]);
res = max(res, c[i][j]);
}
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(10);
int N, K;
cin >> N >> K;
VI h(N);
REP(i, N) cin >> h[i];
VI dp(N, INF);
dp[0] = 0;
REP(i, N - 1) {
FOR(j, 1, min(K + 1, N)) {
if (i + j <= N - 1)
chmin(dp[i + j], dp[i] + abs(h[i] - h[i + j]));
}
}
cout << dp[N - 1] << endl;
} | [
"identifier.change",
"call.function.change",
"call.arguments.add"
] | 959,417 | 959,418 | u313403396 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, mn = 10000;
cin >> n >> m;
int a[n + 1];
for (int k = 1; k <= n; k++)
cin >> a[k];
int d[n + 1];
d[1] = 0;
d[0] = 0;
d[2] = abs(a[1] - a[2]);
for (int k = 3; k <= n; k++) {
mn = 10000;
if (m <= k - 1) {
for (int i = k - m; i < k; i++)
mn = min(mn, d[i] + abs(a[i] - a[k]));
} else {
for (int i = 1; i < k; i++)
mn = min(mn, d[i] + abs(a[i] - a[k]));
}
d[k] = mn;
}
cout << d[n];
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, mn = 1000000000;
cin >> n >> m;
int a[n + 1];
for (int k = 1; k <= n; k++)
cin >> a[k];
int d[n + 1];
d[1] = 0;
d[0] = 0;
d[2] = abs(a[1] - a[2]);
for (int k = 3; k <= n; k++) {
mn = 1000000000;
if (m <= k - 1) {
for (int i = k - m; i < k; i++)
mn = min(mn, d[i] + abs(a[i] - a[k]));
} else {
for (int i = 1; i < k; i++)
mn = min(mn, d[i] + abs(a[i] - a[k]));
}
d[k] = mn;
}
cout << d[n];
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change",
"assignment.value.change"
] | 959,419 | 959,420 | u350462185 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, k, j, m;
cin >> n >> k;
int h[n], c[n];
for (i = 0; i < n; i++) {
cin >> h[i];
c[i] = 99999;
}
c[0] = 0;
for (i = 0; i < n - 1; i++) {
for (j = 1; j <= k; j++) {
if (i + j < n) {
m = c[i] + abs(h[i + j] - h[i]);
if (m < c[i + j])
c[i + j] = m;
}
}
}
cout << c[n - 1];
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, k, j, m;
cin >> n >> k;
long int h[n], c[n];
for (i = 0; i < n; i++) {
cin >> h[i];
c[i] = 999999999;
}
c[0] = 0;
for (i = 0; i < n - 1; i++) {
for (j = 1; j <= k; j++) {
if (i + j < n) {
m = c[i] + abs(h[i + j] - h[i]);
if (m < c[i + j])
c[i + j] = m;
}
}
}
cout << c[n - 1];
}
| [
"variable_declaration.type.widen.change",
"literal.number.change",
"assignment.value.change"
] | 959,421 | 959,422 | u723607904 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int INF = 1e9 + 5;
int main() {
int n, k;
cin >> n >> k;
vector<int> h(n);
for (int &x : h)
cin >> x;
vector<int> dp(n, INF);
dp[0] = 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(h[i] - h[j]));
}
}
}
cout << dp[n - 1];
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int INF = 1e9 + 5;
int main() {
int n, k;
cin >> n >> k;
vector<int> h(n);
for (int &x : h)
cin >> 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(h[i] - h[j]));
}
}
}
cout << dp[n - 1];
return 0;
} | [
"identifier.change"
] | 959,425 | 959,426 | u700811072 | cpp |
p03161 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int abs(int a, int b) {
if (a >= b)
return a - b;
else
return b - a;
}
int main() {
int n, k;
cin >> n >> k;
vector<int> h(n);
rep(i, n) cin >> h[i];
vector<ll> d(n);
rep(i, n - 1) d[i + 1] = 10 ^ 9 + 5;
d[0] = 0;
rep(i, n - 1) {
for (int j = i; j >= max(0, i - k + 1); j--) {
int dtemp = d[j] + abs(h[j], h[i + 1]);
if (d[i + 1] > dtemp)
d[i + 1] = dtemp;
}
}
cout << d[n - 1];
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int abs(int a, int b) {
if (a >= b)
return a - b;
else
return b - a;
}
int main() {
int n, k;
cin >> n >> k;
vector<int> h(n);
rep(i, n) cin >> h[i];
vector<ll> d(n);
rep(i, n - 1) d[i + 1] = pow(10, 9) + 5;
d[0] = 0;
rep(i, n - 1) {
for (int j = i; j >= max(0, i - k + 1); j--) {
int dtemp = d[j] + abs(h[j], h[i + 1]);
if (d[i + 1] > dtemp)
d[i + 1] = dtemp;
}
}
cout << d[n - 1];
}
| [
"call.add",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 959,427 | 959,428 | u164112876 | cpp |
p03161 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int abs(int a, int b) {
if (a >= b)
return a - b;
else
return b - a;
}
int main() {
int n, k;
cin >> n >> k;
vector<int> h(n);
rep(i, n) cin >> h[i];
vector<int> d(n);
rep(i, n - 1) d[i + 1] = 10 ^ 9 + 5;
d[0] = 0;
rep(i, n - 1) {
for (int j = i; j >= max(0, i - k + 1); j--) {
int dtemp = d[j] + abs(h[j], h[i + 1]);
if (d[i + 1] > dtemp)
d[i + 1] = dtemp;
}
}
cout << d[n - 1];
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int abs(int a, int b) {
if (a >= b)
return a - b;
else
return b - a;
}
int main() {
int n, k;
cin >> n >> k;
vector<int> h(n);
rep(i, n) cin >> h[i];
vector<ll> d(n);
rep(i, n - 1) d[i + 1] = pow(10, 9) + 5;
d[0] = 0;
rep(i, n - 1) {
for (int j = i; j >= max(0, i - k + 1); j--) {
int dtemp = d[j] + abs(h[j], h[i + 1]);
if (d[i + 1] > dtemp)
d[i + 1] = dtemp;
}
}
cout << d[n - 1];
}
| [
"call.add",
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 959,429 | 959,428 | u164112876 | cpp |
p03161 | #include <bits/stdc++.h>
#define ll long long int
#define mod 1000000007
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll n, k;
cin >> n >> k;
ll arr[n + 1];
for (int a = 1; a <= n; a++)
cin >> arr[a];
ll dp[n + 1];
dp[1] = 0;
for (int a = 2; a <= k + 1; a++) {
dp[a] = abs(arr[a] - arr[1]);
}
for (int a = k + 2; a <= n; a++) {
ll x, y, z;
ll mini = 1000000000000000;
for (int b = 1; b <= k; b++) {
x = dp[a - b] + abs(arr[a] - arr[a - b]);
mini = min(mini, x);
}
dp[a] = mini;
}
cout << dp[n] << endl;
return 0;
} | #include <bits/stdc++.h>
#define ll long long int
#define mod 1000000007
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll n, k;
cin >> n >> k;
ll arr[n + 1];
for (int a = 1; a <= n; a++)
cin >> arr[a];
ll dp[n + 1];
dp[1] = 0;
for (int a = 2; a <= min(n, k + 1); a++) {
dp[a] = abs(arr[a] - arr[1]);
}
for (int a = k + 2; a <= n; a++) {
ll x, y, z;
ll mini = 1000000000000000;
for (int b = 1; b <= k; b++) {
x = dp[a - b] + abs(arr[a] - arr[a - b]);
mini = min(mini, x);
}
dp[a] = mini;
}
cout << dp[n] << endl;
return 0;
} | [
"control_flow.loop.for.condition.change",
"call.add",
"call.arguments.change"
] | 959,432 | 959,433 | u064666849 | cpp |
p03161 | #include <bits/stdc++.h>
#define ll long long int
#define mod 1000000007
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll n, k;
cin >> n >> k;
ll arr[n + 1];
for (int a = 1; a <= n; a++)
cin >> arr[a];
ll dp[n + 1];
dp[1] = 0;
for (int a = 2; a <= k + 1; a++) {
dp[a] = abs(arr[a] - arr[1]);
}
for (int a = k + 2; a <= n; a++) {
ll x, y, z;
ll mini = 1000000000000000;
for (int b = 1; b <= k; b++) {
x = dp[a - b] + abs(arr[a] - arr[a - b]);
mini = min(mini, x);
}
dp[a] = mini;
}
cout << dp[n] << endl;
return 0;
}
| #include <bits/stdc++.h>
#define ll long long int
#define mod 1000000007
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll n, k;
cin >> n >> k;
ll arr[n + 1];
for (int a = 1; a <= n; a++)
cin >> arr[a];
ll dp[n + 1];
dp[1] = 0;
for (int a = 2; a <= min(n, k + 1); a++) {
dp[a] = abs(arr[a] - arr[1]);
}
for (int a = k + 2; a <= n; a++) {
ll x, y, z;
ll mini = 1000000000000000;
for (int b = 1; b <= k; b++) {
x = dp[a - b] + abs(arr[a] - arr[a - b]);
mini = min(mini, x);
}
dp[a] = mini;
}
cout << dp[n] << endl;
return 0;
} | [
"control_flow.loop.for.condition.change",
"call.add",
"call.arguments.change"
] | 959,434 | 959,433 | u064666849 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define REP(i, n) for (ll i = 0, i##_len = (n); i < i##_len; ++i)
#define REPR(i, n) for (ll i = n; i >= 0; --i)
#define FOR(i, m, n) for (ll i = m, i##_len = (n); i < i##_len; ++i)
#define all(x) (x).begin(), (x).end()
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
const int INF = 1e9;
const ll LLINF = 1e16;
ll modinv(ll a, ll m) {
ll b = m, u = 1, v = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
int main(void) {
ll n, k;
cin >> n >> k;
vector<int> h(n);
REP(i, n) cin >> h[i];
vector<ll> cost(n, 0);
FOR(i, 1, n) {
cost[i] = LLINF;
FOR(j, i - k, i) { chmin(cost[i], abs(h[i] - h[j]) + cost[j]); }
}
cout << cost[n - 1] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define REP(i, n) for (ll i = 0, i##_len = (n); i < i##_len; ++i)
#define REPR(i, n) for (ll i = n; i >= 0; --i)
#define FOR(i, m, n) for (ll i = m, i##_len = (n); i < i##_len; ++i)
#define all(x) (x).begin(), (x).end()
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
const int INF = 1e9;
const ll LLINF = 1e16;
ll modinv(ll a, ll m) {
ll b = m, u = 1, v = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
int main(void) {
ll n, k;
cin >> n >> k;
vector<int> h(n);
REP(i, n) cin >> h[i];
vector<ll> cost(n, 0);
FOR(i, 1, n) {
cost[i] = LLINF;
FOR(j, max(0ll, i - k), i) { chmin(cost[i], abs(h[i] - h[j]) + cost[j]); }
}
cout << cost[n - 1] << endl;
return 0;
} | [
"call.add",
"call.arguments.change"
] | 959,437 | 959,438 | u272997285 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int N, K;
cin >> N >> K;
vector<ll> h(N);
vector<ll> dp(100, 1000000000);
for (int i = 0; i < N; i++)
cin >> h[i];
dp[0] = 0;
dp[1] = abs(h[1] - h[0]);
for (int i = 2; i < N; i++) {
for (int j = 1; j <= K; j++) {
if (i >= j)
dp[i] = min(dp[i], dp[i - j] + abs(h[i] - h[i - j]));
}
}
cout << dp[N - 1] << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int N, K;
cin >> N >> K;
vector<ll> h(N);
vector<ll> dp(100000, 1000000000);
for (int i = 0; i < N; i++)
cin >> h[i];
dp[0] = 0;
dp[1] = abs(h[1] - h[0]);
for (int i = 2; i < N; i++) {
for (int j = 1; j <= K; j++) {
if (i >= j)
dp[i] = min(dp[i], dp[i - j] + abs(h[i] - h[i - j]));
}
}
cout << dp[N - 1] << endl;
}
| [
"literal.number.change",
"call.arguments.change"
] | 959,445 | 959,444 | u964763428 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int N, K;
cin >> N >> K;
vector<int> h(N);
vector<ll> dp(100, 1000000000);
for (int i = 0; i < N; i++)
cin >> h[i];
dp[0] = 0;
dp[1] = abs(h[1] - h[0]);
for (int i = 2; i < N; i++) {
for (int j = 1; j <= K; j++) {
if (i >= j)
dp[i] = min(dp[i], dp[i - j] + abs(h[i] - h[i - j]));
}
}
cout << dp[N - 1] << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int N, K;
cin >> N >> K;
vector<ll> h(N);
vector<ll> dp(100000, 1000000000);
for (int i = 0; i < N; i++)
cin >> h[i];
dp[0] = 0;
dp[1] = abs(h[1] - h[0]);
for (int i = 2; i < N; i++) {
for (int j = 1; j <= K; j++) {
if (i >= j)
dp[i] = min(dp[i], dp[i - j] + abs(h[i] - h[i - j]));
}
}
cout << dp[N - 1] << endl;
}
| [
"literal.number.change",
"call.arguments.change"
] | 959,446 | 959,444 | u964763428 | cpp |
p03161 | #include <bits/stdc++.h>
#define ll long long
#define mo 1000000009
using namespace std;
int main() {
ll n, mini, k;
cin >> n >> k;
ll a[n], dp[n];
for (ll i = 0; i < n; i++)
cin >> a[i];
dp[0] = 0;
dp[1] = abs(a[1] - a[0]);
for (ll i = 2; i < n; i++) {
mini = 100000;
for (ll j = i - 1; j >= i - k && j >= 0; j--) {
if (abs(a[i] - a[j]) + dp[j] < mini)
mini = abs(a[i] - a[j]) + dp[j];
}
dp[i] = mini;
}
cout << dp[n - 1];
return 0;
} | #include <bits/stdc++.h>
#define ll long long
#define mo 1000000009
using namespace std;
int main() {
ll n, mini, k;
cin >> n >> k;
ll a[n], dp[n];
for (ll i = 0; i < n; i++)
cin >> a[i];
dp[0] = 0;
dp[1] = abs(a[1] - a[0]);
for (ll i = 2; i < n; i++) {
mini = 10000000000;
for (ll j = i - 1; j >= i - k && j >= 0; j--) {
if (abs(a[i] - a[j]) + dp[j] < mini)
mini = abs(a[i] - a[j]) + dp[j];
}
dp[i] = mini;
}
cout << dp[n - 1];
return 0;
} | [
"literal.number.change",
"assignment.value.change"
] | 959,456 | 959,457 | u349761723 | cpp |
p03161 | #include <bits/stdc++.h>
#define endl '\n'
#define fi first
#define se second
#define pb push_back
#define debug(x) cout << "[debug] " << #x << ": " << x << endl
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
const int MOD = 1e9 + 7;
const int maxn = 1e6 + 5;
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;
int h[maxn], dp[maxn];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++)
scanf("%d", &h[i]), dp[i] = inf;
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(h[i] - h[i - j]));
}
printf("%d\n", dp[n]);
return 0;
}
| #include <bits/stdc++.h>
#define endl '\n'
#define fi first
#define se second
#define pb push_back
#define debug(x) cout << "[debug] " << #x << ": " << x << endl
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
const int MOD = 1e9 + 7;
const int maxn = 1e6 + 5;
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;
int h[maxn], dp[maxn];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++)
scanf("%d", &h[i]), dp[i] = inf;
dp[1] = 0;
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= min(i - 1, k); j++)
dp[i] = min(dp[i], dp[i - j] + abs(h[i] - h[i - j]));
}
printf("%d\n", dp[n]);
return 0;
}
| [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 959,458 | 959,459 | u789157713 | cpp |
p03161 | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
const int N = 1e5 + 11;
typedef long long ll;
ll f[N], h[N];
int main() {
memset(f, 0x3f, sizeof f);
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i)
scanf("%lld", &h[i]);
f[1] = 0;
for (int i = 1; i <= n; ++i)
for (int j = i - 1; j >= i - k; --j)
f[i] = min(f[j] + abs(h[i] - h[j]), f[i]);
cout << f[n];
return 0;
}
| #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
const int N = 1e5 + 11;
typedef long long ll;
ll f[N], h[N];
int main() {
memset(f, 0x3f, sizeof f);
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i)
scanf("%lld", &h[i]);
f[1] = 0;
for (int i = 1; i <= n; ++i)
for (int j = i - 1; j >= i - k && j >= 1; --j)
f[i] = min(f[j] + abs(h[i] - h[j]), f[i]);
cout << f[n];
return 0;
}
| [
"control_flow.loop.for.condition.change"
] | 959,466 | 959,467 | u067001883 | cpp |
p03161 | #include <bits/stdc++.h>
#define rep(i, a) for (int i = 0; i < a; i++)
#define rep1(i, a, b) for (int i = a; i < b; i++)
using ll = long long;
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<ll> v(n), dp(n);
rep(i, n) cin >> v[i];
dp[0] = 0;
rep1(i, 2, n) {
dp[i] = LONG_LONG_MAX;
rep1(j, 1, k + 1) if (i >= j) dp[i] =
min(dp[i], dp[i - j] + abs(v[i] - v[i - j]));
}
// rep(i, n) cout<<dp[i]<<" ";
cout << dp[n - 1] << endl;
} | #include <bits/stdc++.h>
#define rep(i, a) for (int i = 0; i < a; i++)
#define rep1(i, a, b) for (int i = a; i < b; i++)
using ll = long long;
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<ll> v(n), dp(n);
rep(i, n) cin >> v[i];
dp[0] = 0;
rep1(i, 1, n) {
dp[i] = LONG_LONG_MAX;
rep1(j, 1, k + 1) if (i >= j) dp[i] =
min(dp[i], dp[i - j] + abs(v[i] - v[i - j]));
}
// rep(i, n) cout<<dp[i]<<" ";
cout << dp[n - 1] << endl;
} | [
"literal.number.change",
"call.arguments.change"
] | 959,474 | 959,475 | u624118226 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
long long n, k, i, j, ans;
long long a[2000001], dp[2000001];
main() {
cin >> n >> k;
for (i = 1; i <= n; i++)
cin >> a[i];
dp[2] = abs(a[2] - a[1]);
for (i = 2; i <= n; i++) {
ans = 1e9;
for (j = 0; j < min(n, k); j++) {
ans = min(ans, dp[i - j] + abs(a[i + 1] - a[i - j]));
}
dp[i + 1] = ans;
}
cout << dp[n] << endl;
} | #include <bits/stdc++.h>
using namespace std;
long long n, k, i, j, ans;
long long a[2000001], dp[2000001];
main() {
cin >> n >> k;
for (i = 1; i <= n; i++)
cin >> a[i];
dp[2] = abs(a[2] - a[1]);
for (i = 2; i < n; i++) {
ans = 1e9;
for (j = 0; j < min(i, k); j++) {
ans = min(ans, dp[i - j] + abs(a[i + 1] - a[i - j]));
}
dp[i + 1] = ans;
}
cout << dp[n] << endl;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"identifier.change",
"call.arguments.change"
] | 959,489 | 959,490 | u049755721 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
long long n, k, i, j, ans;
long long a[2000001], dp[2000001];
main() {
cin >> n >> k;
for (i = 1; i <= n; i++)
cin >> a[i];
dp[2] = abs(a[2] - a[1]);
for (i = 2; i <= n; i++) {
ans = 1e9;
for (j = 0; j < k; j++) {
ans = min(ans, dp[i - j] + abs(a[i + 1] - a[i - j]));
}
dp[i + 1] = ans;
}
cout << dp[n] << endl;
} | #include <bits/stdc++.h>
using namespace std;
long long n, k, i, j, ans;
long long a[2000001], dp[2000001];
main() {
cin >> n >> k;
for (i = 1; i <= n; i++)
cin >> a[i];
dp[2] = abs(a[2] - a[1]);
for (i = 2; i < n; i++) {
ans = 1e9;
for (j = 0; j < min(i, k); j++) {
ans = min(ans, dp[i - j] + abs(a[i + 1] - a[i - j]));
}
dp[i + 1] = ans;
}
cout << dp[n] << endl;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"call.add",
"call.arguments.change"
] | 959,491 | 959,490 | u049755721 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
int n, k = 2, a[100001], dp[100001];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
dp[i] = 1e9;
cin >> a[i];
if (i == 1) {
dp[i] = 0;
continue;
}
for (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];
} | #include <bits/stdc++.h>
using namespace std;
int n, k, a[100001], dp[100001];
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
dp[i] = 1e9;
cin >> a[i];
if (i == 1) {
dp[i] = 0;
continue;
}
for (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];
} | [
"expression.operation.binary.add"
] | 959,492 | 959,493 | u630713695 | cpp |
p03161 | #include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#define rep(i, n) for (int(i) = 0; (i) < (n); ++(i))
#define _Pi 3.1415926535
#define _MOD = 1e9 + 7;
using namespace std;
typedef long long ll;
int main() {
int n, k;
cin >> n >> k;
vector<int> h(100000);
rep(i, n) cin >> h[i];
vector<int> cost(100000, 100000);
cost[0] = 0;
for (int i = 0; i < n; ++i) {
for (int j = 1; j <= k; ++j) {
cost[i + j] = min(cost[i + j], cost[i] + abs(h[i + j] - h[i]));
}
}
cout << cost[n - 1] << endl;
return 0;
}
| #include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#define rep(i, n) for (int(i) = 0; (i) < (n); ++(i))
#define _Pi 3.1415926535
#define _MOD = 1e9 + 7;
using namespace std;
typedef long long ll;
int main() {
int n, k;
cin >> n >> k;
vector<int> h(100000);
rep(i, n) cin >> h[i];
vector<int> cost(100000, INT_MAX);
cost[0] = 0;
for (int i = 0; i < n; ++i) {
for (int j = 1; j <= k; ++j) {
cost[i + j] = min(cost[i + j], cost[i] + abs(h[i + j] - h[i]));
}
}
cout << cost[n - 1] << endl;
return 0;
}
| [
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change"
] | 959,496 | 959,497 | u445457059 | cpp |
p03161 | #include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#define rep(i, n) for (int(i) = 0; (i) < (n); ++(i))
#define _Pi 3.1415926535
#define _MOD = 1e9 + 7;
using namespace std;
typedef long long ll;
int main() {
int n, k;
cin >> n >> k;
vector<int> h(n);
rep(i, n) cin >> h[i];
vector<int> cost(n, 1 << 20);
cost[0] = 0;
for (int i = 0; i < n; ++i) {
for (int j = 1; j <= k; ++j) {
cost[i + j] = min(cost[i + j], cost[i] + abs(h[i + j] - h[i]));
}
}
cout << cost[n - 1] << endl;
return 0;
}
| #include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#define rep(i, n) for (int(i) = 0; (i) < (n); ++(i))
#define _Pi 3.1415926535
#define _MOD = 1e9 + 7;
using namespace std;
typedef long long ll;
int main() {
int n, k;
cin >> n >> k;
vector<int> h(100000);
rep(i, n) cin >> h[i];
vector<int> cost(100000, INT_MAX);
cost[0] = 0;
for (int i = 0; i < n; ++i) {
for (int j = 1; j <= k; ++j) {
cost[i + j] = min(cost[i + j], cost[i] + abs(h[i + j] - h[i]));
}
}
cout << cost[n - 1] << endl;
return 0;
}
| [
"identifier.replace.remove",
"literal.replace.add",
"call.arguments.change",
"identifier.replace.add",
"literal.replace.remove",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 959,500 | 959,497 | u445457059 | cpp |
p03161 | #include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#define rep(i, n) for (int(i) = 0; (i) < (n); ++(i))
#define _Pi 3.1415926535
#define _MOD = 1e9 + 7;
using namespace std;
typedef long long ll;
int main() {
int n, k;
cin >> n >> k;
vector<int> h(100000);
rep(i, n) cin >> h[i];
vector<int> cost(100000, 100000);
cost[0] = 0;
for (int i = 0; i < n; ++i) {
for (int j = 1; j <= k; ++j) {
cost[i + j] = min(cost[i + j], cost[i] + abs(h[i + j] - h[i]));
}
}
cout << cost[n - 1] << endl;
return 0;
}
| #include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#define rep(i, n) for (int(i) = 0; (i) < (n); ++(i))
#define _Pi 3.1415926535
#define _MOD = 1e9 + 7;
using namespace std;
typedef long long ll;
int main() {
int n, k;
cin >> n >> k;
vector<int> h(100000);
rep(i, n) cin >> h[i];
vector<int> cost(100000, 1 << 30);
cost[0] = 0;
for (int i = 0; i < n; ++i) {
for (int j = 1; j <= k; ++j) {
cost[i + j] = min(cost[i + j], cost[i] + abs(h[i + j] - h[i]));
}
}
cout << cost[n - 1] << endl;
return 0;
}
| [
"literal.number.change",
"call.arguments.change"
] | 959,496 | 959,501 | u445457059 | cpp |
p03161 | #include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#define rep(i, n) for (int(i) = 0; (i) < (n); ++(i))
#define _Pi 3.1415926535
#define _MOD = 1e9 + 7;
using namespace std;
typedef long long ll;
int main() {
int n, k;
cin >> n >> k;
vector<int> h(n);
rep(i, n) cin >> h[i];
vector<int> cost(n, 1 << 20);
cost[0] = 0;
for (int i = 0; i < n; ++i) {
for (int j = 1; j <= k; ++j) {
cost[i + j] = min(cost[i + j], cost[i] + abs(h[i + j] - h[i]));
}
}
cout << cost[n - 1] << endl;
return 0;
}
| #include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#define rep(i, n) for (int(i) = 0; (i) < (n); ++(i))
#define _Pi 3.1415926535
#define _MOD = 1e9 + 7;
using namespace std;
typedef long long ll;
int main() {
int n, k;
cin >> n >> k;
vector<int> h(100000);
rep(i, n) cin >> h[i];
vector<int> cost(100000, 1 << 30);
cost[0] = 0;
for (int i = 0; i < n; ++i) {
for (int j = 1; j <= k; ++j) {
cost[i + j] = min(cost[i + j], cost[i] + abs(h[i + j] - h[i]));
}
}
cout << cost[n - 1] << endl;
return 0;
}
| [
"identifier.replace.remove",
"literal.replace.add",
"call.arguments.change",
"literal.number.change",
"expression.operation.binary.change"
] | 959,500 | 959,501 | u445457059 | cpp |
p03161 | #include <bits/stdc++.h>
#define FIO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define PI 3.141592653589793238462643383279502884L
#define lli long long int
#define d double
using namespace std;
int main() {
FIO;
lli n, k;
cin >> n >> k;
vector<lli> vec(n + 1);
for (lli i = 1; i <= n; i++)
cin >> vec[i];
vector<lli> dp(n);
dp[1] = 0;
dp[2] = abs(vec[2] - vec[1]);
for (lli i = 3; i <= n; i++) {
dp[i] = INT_MAX;
for (lli j = i - 1; j >= i - k && j >= 0; j--) {
dp[i] = min(dp[i], dp[j] + abs(vec[i] - vec[j]));
}
}
cout << dp[n] << endl;
return 0;
} | #include <bits/stdc++.h>
#define FIO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define PI 3.141592653589793238462643383279502884L
#define lli long long int
#define d double
using namespace std;
int main() {
FIO;
lli n, k;
cin >> n >> k;
vector<lli> vec(n + 1);
for (lli i = 1; i <= n; i++)
cin >> vec[i];
vector<lli> dp(n);
dp[1] = 0;
dp[2] = abs(vec[2] - vec[1]);
for (lli i = 3; i <= n; i++) {
dp[i] = INT_MAX;
for (lli j = i - 1; j >= i - k && j >= 1; j--) {
dp[i] = min(dp[i], dp[j] + abs(vec[i] - vec[j]));
}
}
cout << dp[n] << endl;
return 0;
} | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 959,504 | 959,505 | u203396615 | cpp |
p03161 | #include <bits/stdc++.h>
#define ll long long
#define mx 200005
#define mod 1000000007
#define mxm 999999999999
using namespace std;
ll dp[mx];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll a[mx], i, n, k, j;
cin >> n >> k;
for (i = 1; i < n + 1; i++)
cin >> a[i];
dp[1] = 0;
/*dp[2]=abs(a[2]-a[1]);
for(i=3;i<n+1;i++)
dp[i]=min(dp[i-2]+abs(a[i]-a[i-2]),dp[i-1]+abs(a[i]-a[i-1]));*/
for (i = 2; i < n + 1; i++) {
ll mnm = mxm;
for (j = i - 1; j > -1 && j > i - k - 1; j--) {
mnm = min(mnm, dp[j] + abs(a[i] - a[j]));
}
dp[i] = mnm;
}
cout << dp[n];
return 0;
} | #include <bits/stdc++.h>
#define ll long long
#define mx 200005
#define mod 1000000007
#define mxm 999999999999
using namespace std;
ll dp[mx];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll a[mx], i, n, k, j;
cin >> n >> k;
for (i = 1; i < n + 1; i++)
cin >> a[i];
dp[1] = 0;
/*dp[2]=abs(a[2]-a[1]);
for(i=3;i<n+1;i++)
dp[i]=min(dp[i-2]+abs(a[i]-a[i-2]),dp[i-1]+abs(a[i]-a[i-1]));*/
for (i = 2; i < n + 1; i++) {
ll mnm = mxm;
for (j = i - 1; j > 0 && j > i - k - 1; j--) {
mnm = min(mnm, dp[j] + abs(a[i] - a[j]));
}
dp[i] = mnm;
}
cout << dp[n];
return 0;
} | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 959,506 | 959,507 | u720296041 | cpp |
p03161 | /*
- 20.3.2
B - Frog 2
Atcoder-Educational DP Contest-B - Frog 2
20.3.2-Atcoder-Educational DP Contest-B - Frog 2-
-
-
-
*/
#include <bits/stdc++.h>
using namespace std;
int f[100010], h[100010];
int n, k;
int main() {
cin >> n >> k >> h[1];
f[1] = 0;
for (int i = 2; i <= n; ++i) {
cin >> h[i];
f[i] = 2e9;
for (int j = i - k; j < i; ++j)
f[i] = min(f[i], f[j] + abs(h[i] - h[j]));
}
cout << f[n] << endl;
return 0;
} | /*
- 20.3.2
B - Frog 2
Atcoder-Educational DP Contest-B - Frog 2
20.3.2-Atcoder-Educational DP Contest-B - Frog 2-
-
-
-
*/
#include <bits/stdc++.h>
using namespace std;
int f[100010], h[100010];
int n, k;
int main() {
cin >> n >> k >> h[1];
f[1] = 0;
for (int i = 2; i <= n; ++i) {
cin >> h[i];
f[i] = 2e9;
for (int j = max(i - k, 1); j < i; ++j)
f[i] = min(f[i], f[j] + abs(h[i] - h[j]));
}
cout << f[n] << endl;
return 0;
} | [
"control_flow.loop.for.initializer.change",
"call.add",
"call.arguments.add"
] | 959,510 | 959,511 | u244314173 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define trace(x) cerr << #x << " : " << x << endl;
ll max(ll a, ll b) { return (a > b ? a : b); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll n, k;
cin >> n >> k;
ll a[n + 1], c[n + 1] = {0};
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
c[1] = 0;
c[2] = abs(a[2] - a[1]);
for (int i = 3; i <= n; ++i) {
c[i] = c[i - 1] + abs(a[i] - a[i - 1]);
for (int j = i - 2; j >= max(0, i - k); j--)
c[i] = min(c[i], c[j] + abs(a[i] - a[j]));
}
cout << c[n];
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define trace(x) cerr << #x << " : " << x << endl;
ll max(ll a, ll b) { return (a > b ? a : b); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll n, k;
cin >> n >> k;
ll a[n + 1], c[n + 1] = {0};
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
c[1] = 0;
c[2] = abs(a[2] - a[1]);
for (int i = 3; i <= n; ++i) {
c[i] = c[i - 1] + abs(a[i] - a[i - 1]);
for (int j = i - 2; j >= max(1, i - k); j--)
c[i] = min(c[i], c[j] + abs(a[i] - a[j]));
}
cout << c[n];
return 0;
} | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"call.arguments.change",
"expression.operation.binary.change"
] | 959,514 | 959,515 | u755134895 | cpp |
p03161 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
using namespace std;
using ll = long long;
using itn = int;
const ll MOD = 1000000007;
const ll INF = MOD * MOD;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
ll dp[100010];
int main() {
int n, k;
cin >> n >> k;
vector<int> h(n);
for (int i = 0; i < n; i++) {
cin >> h[i];
}
for (int i = 0; i < 100010; i++) {
dp[i] = INF;
}
dp[0] = 0;
for (int i = 1; i < n; i++) {
for (int j = 1; j <= k; j++) {
chmin(dp[i + j], dp[i] + abs(h[i] - h[i + j]));
// if (i-j >= 0) chmin(dp[i], dp[i-j] + abs(h[i] - h[i-j]));
}
}
cout << dp[n - 1] << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
using namespace std;
using ll = long long;
using itn = int;
const ll MOD = 1000000007;
const ll INF = MOD * MOD;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
ll dp[100010];
int main() {
int n, k;
cin >> n >> k;
vector<int> h(n);
for (int i = 0; i < n; i++) {
cin >> h[i];
}
for (int i = 0; i < 100010; i++) {
dp[i] = INF;
}
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= k; j++) {
chmin(dp[i + j], dp[i] + abs(h[i] - h[i + j]));
// if (i-j >= 0) chmin(dp[i], dp[i-j] + abs(h[i] - h[i-j]));
}
}
cout << dp[n - 1] << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 959,516 | 959,517 | u538125576 | cpp |
p03161 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
using namespace std;
using ll = long long;
using itn = int;
const ll MOD = 1000000007;
const ll INF = MOD * MOD;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
ll dp[100010];
int main() {
int n, k;
cin >> n >> k;
vector<int> h(n);
for (int i = 0; i < n; i++) {
cin >> h[i];
}
for (int i = 0; i < 100010; i++) {
dp[i] = 100010;
}
dp[0] = 0;
for (int i = 1; i < n; i++) {
for (int j = 1; j <= k; j++) {
if (i - j >= 0)
chmin(dp[i], dp[i - j] + abs(h[i] - h[i - j]));
}
}
cout << dp[n - 1] << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
using namespace std;
using ll = long long;
using itn = int;
const ll MOD = 1000000007;
const ll INF = MOD * MOD;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
ll dp[100010];
int main() {
int n, k;
cin >> n >> k;
vector<int> h(n);
for (int i = 0; i < n; i++) {
cin >> h[i];
}
for (int i = 0; i < 100010; i++) {
dp[i] = INF;
}
dp[0] = 0;
for (int i = 1; i < n; i++) {
for (int j = 1; j <= k; j++) {
if (i - j >= 0)
chmin(dp[i], dp[i - j] + abs(h[i] - h[i - j]));
}
}
cout << dp[n - 1] << endl;
return 0;
} | [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 959,518 | 959,519 | u538125576 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
const long long INF = 1LL << 60;
template <typename T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
// 入力
int N, K;
long long h[100010];
// DP テーブル
long long dp[100010];
int main() {
int N;
cin >> N;
int K;
cin >> K;
for (int i = 0; i < N; ++i)
cin >> h[i];
// 初期化 (最小化問題なので INF に初期化)
for (int i = 0; i < 100010; ++i)
dp[i] = INF;
// 初期条件
dp[0] = 0;
for (int i = 1; i < N; i++) {
if (i < K) {
for (int j = 0; j < i; j++) {
chmin(dp[i], dp[i - j] + abs(h[i] - h[i - j]));
}
} else {
for (int j = 0; j < K; j++) {
chmin(dp[i], dp[i - j] + abs(h[i] - h[i - j]));
}
}
}
cout << dp[N - 1] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const long long INF = 1LL << 60;
template <typename T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
// 入力
int N, K;
long long h[100010];
// DP テーブル
long long dp[100010];
int main() {
int N;
cin >> N;
int K;
cin >> K;
for (int i = 0; i < N; ++i)
cin >> h[i];
// 初期化 (最小化問題なので INF に初期化)
for (int i = 0; i < 100010; ++i)
dp[i] = INF;
// 初期条件
dp[0] = 0;
for (int i = 1; i < N; i++) {
if (i < K) {
for (int j = 0; j <= i; j++) {
chmin(dp[i], dp[i - j] + abs(h[i] - h[i - j]));
}
} else {
for (int j = 0; j <= K; j++) {
chmin(dp[i], dp[i - j] + abs(h[i] - h[i - j]));
}
}
}
cout << dp[N - 1] << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 959,525 | 959,526 | u840823723 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int dp[n];
int arr[n];
for (int i = 0; i < n; ++i) {
cin >> arr[i];
dp[i] = 100000;
}
dp[0] = 0;
dp[1] = abs(arr[1] - arr[0]);
for (int i = 2; i < n; ++i) {
for (int kk = 1; kk <= k; ++kk) {
if (i - kk >= 0)
dp[i] = min(dp[i], dp[i - kk] + abs(arr[i - kk] - arr[i]));
}
}
cout << dp[n - 1];
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int dp[n];
int arr[n];
for (int i = 0; i < n; ++i) {
cin >> arr[i];
dp[i] = 10000000000;
}
dp[0] = 0;
dp[1] = abs(arr[1] - arr[0]);
for (int i = 2; i < n; ++i) {
for (int kk = 1; kk <= k; ++kk) {
if (i - kk >= 0)
dp[i] = min(dp[i], dp[i - kk] + abs(arr[i - kk] - arr[i]));
}
}
cout << dp[n - 1];
} | [
"literal.number.change",
"assignment.value.change"
] | 959,538 | 959,535 | u012046378 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define f first
#define s second
#define Mp make_pair
#define pb push_back
#define Lb lower_bound
#define Ub upper_bound
#define all(x) x.begin(), x.end()
#define fast_io ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
const int Maxn = 100000 + 5, N = 100 + 5, Mod = 1000 * 1000 * 1000 + 7,
inf = 1000 * 1000 * 1000;
int n, k, h[Maxn], dp[Maxn];
int main() {
fast_io cin >> n >> k;
for (int i = 0; i < n; i++)
cin >> h[i];
for (int i = 1; i < k; i++) {
dp[i] = abs(h[i] - h[0]);
}
for (int i = k; i < n; i++) {
dp[i] = inf;
for (int j = i - k; j <= i - k; j++) {
dp[i] = min(dp[i], dp[j] + abs(h[i] - h[j]));
}
}
cout << dp[n - 1];
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define f first
#define s second
#define Mp make_pair
#define pb push_back
#define Lb lower_bound
#define Ub upper_bound
#define all(x) x.begin(), x.end()
#define fast_io ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
const int Maxn = 100000 + 5, N = 100 + 5, Mod = 1000 * 1000 * 1000 + 7,
inf = 1000 * 1000 * 1000;
int n, k, h[Maxn], dp[Maxn];
int main() {
fast_io cin >> n >> k;
for (int i = 0; i < n; i++)
cin >> h[i];
for (int i = 1; i < k; i++) {
dp[i] = abs(h[i] - h[0]);
}
for (int i = k; i < n; i++) {
dp[i] = inf;
for (int j = i - k; j <= i - 1; j++) {
dp[i] = min(dp[i], dp[j] + abs(h[i] - h[j]));
}
}
cout << dp[n - 1];
return 0;
}
| [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 959,545 | 959,546 | u608076382 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
#define MAXN 100010
#define NEUT 100000
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
cin >> n >> k;
int h[MAXN];
int dp[MAXN];
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
h[i] = x;
}
dp[n] = 0;
/*
for(int i = n - 2; i >= n - k; i--){
int m = abs(h[i]- h[n]);
for(int j = i+1; j < n; j++){
m = min(m, abs(h[j] - h[i]) + dp[j]);
}
dp[i] = m;
}
*/
for (int i = n - k; i <= n; i++) {
dp[i] = abs(h[i] - h[n]);
}
for (int i = n - k - 1; i > 0; i--) {
int m = NEUT;
for (int j = i + 1; j <= i + k; j++) {
m = min(m, abs(h[j] - h[i]) + dp[j]);
}
dp[i] = m;
}
/*
for(int i = 1; i <= n; i++){
cout << dp[i] << " ";
}
cout << "\n";
*/
cout << dp[1] << "\n";
}
| #include <bits/stdc++.h>
using namespace std;
#define MAXN 100010
#define NEUT 1000000000
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
cin >> n >> k;
int h[MAXN];
int dp[MAXN];
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
h[i] = x;
}
dp[n] = 0;
/*
for(int i = n - 2; i >= n - k; i--){
int m = abs(h[i]- h[n]);
for(int j = i+1; j < n; j++){
m = min(m, abs(h[j] - h[i]) + dp[j]);
}
dp[i] = m;
}
*/
for (int i = n - k; i < n; i++) {
dp[i] = abs(h[i] - h[n]);
}
for (int i = n - k - 1; i > 0; i--) {
int m = NEUT;
for (int j = i + 1; j <= i + k; j++) {
m = min(m, abs(h[j] - h[i]) + dp[j]);
}
dp[i] = m;
}
/*
for(int i = 1; i <= n; i++){
cout << dp[i] << " ";
}
cout << "\n";
*/
cout << dp[1] << "\n";
}
| [
"preprocessor.define.value.change",
"literal.integer.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 959,547 | 959,548 | u670715721 | cpp |
p03161 | #include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a), _b = (b); i <= _b; i++)
#define FORN(i, b, a) for (int i = (b); _a = (a); i >= _a; i--)
#define REP(i, n) for (int i = 0, _n = n; i < n; i++)
#define ll long long
#define pii pair<int, int>
#define re return
#define vi vector<int>
#define pb push_back
#define si set<int>
#define in insert
#define fl float
#define db double
#define ld long double
#define X first
#define Y second
#define st string
#define ull unsigned long long
using namespace std;
inline void read(int &x) {
short negative = 1;
x = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-')
negative = -1;
c = getchar();
}
while (c >= '0' && c <= '9')
x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
x *= negative;
}
int main() {
int n, k;
int a[100100];
ll dp[100100];
cin >> n >> k;
REP(i, n)
cin >> a[i];
REP(i, n)
dp[i] = 100000;
dp[0] = 0;
REP(i, n - 1) {
for (int j = 1; j <= k; j++) {
dp[i + j] = min(dp[i + j], abs(a[i + j] - a[i]) + dp[i]);
}
}
cout << dp[n - 1] << endl;
return 0;
}
| #include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a), _b = (b); i <= _b; i++)
#define FORN(i, b, a) for (int i = (b); _a = (a); i >= _a; i--)
#define REP(i, n) for (int i = 0, _n = n; i < n; i++)
#define ll long long
#define pii pair<int, int>
#define re return
#define vi vector<int>
#define pb push_back
#define si set<int>
#define in insert
#define fl float
#define db double
#define ld long double
#define X first
#define Y second
#define st string
#define ull unsigned long long
using namespace std;
inline void read(int &x) {
short negative = 1;
x = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-')
negative = -1;
c = getchar();
}
while (c >= '0' && c <= '9')
x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
x *= negative;
}
int main() {
int n, k;
int a[100100];
ll dp[100100];
cin >> n >> k;
REP(i, n)
cin >> a[i];
REP(i, n)
dp[i] = 1000000007;
dp[0] = 0;
REP(i, n - 1) {
for (int j = 1; j <= k; j++) {
dp[i + j] = min(dp[i + j], abs(a[i + j] - a[i]) + dp[i]);
}
}
cout << dp[n - 1] << endl;
return 0;
}
| [
"literal.number.change",
"assignment.value.change"
] | 959,557 | 959,558 | u638661457 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int arr[n + 1], minarr[n + 1];
for (int i = 1; i <= n; i++)
cin >> arr[i];
minarr[1] = 0;
minarr[2] = abs(arr[2] - arr[1]);
// cout<<minarr[2]<<minarr[3]<<endl;
for (int i = 3; i <= n; i++) {
minarr[i] = 10002;
int j = i - k;
if (j < 0)
j = 0;
while (j < i) {
// cout<<i<<" it comes here";
minarr[i] = min(minarr[j] + abs(arr[j] - arr[i]), minarr[i]);
// cout<<minarr[j]<<endl;
j++;
}
// cout<<i<<" "<<minarr[i]<<endl;
}
// cout<<minarr[3]<<endl;
cout << minarr[n];
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int arr[n + 1], minarr[n + 1];
for (int i = 1; i <= n; i++)
cin >> arr[i];
minarr[1] = 0;
minarr[2] = abs(arr[2] - arr[1]);
// cout<<minarr[2]<<minarr[3]<<endl;
for (int i = 3; i <= n; i++) {
minarr[i] = INT_MAX;
int j = i - k;
if (j <= 0)
j = 1;
while (j < i) {
// cout<<i<<" it comes here";
minarr[i] = min(minarr[j] + abs(arr[j] - arr[i]), minarr[i]);
// cout<<minarr[j]<<endl;
j++;
}
// cout<<i<<" "<<minarr[i]<<endl;
}
// cout<<minarr[3]<<endl;
cout << minarr[n];
return 0;
}
| [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"literal.number.change"
] | 959,559 | 959,560 | u977858417 | cpp |
p03161 | #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
const long long INF = 1LL << 60;
int N;
long long h[110000];
long long dp[110000];
int main() {
int N, K;
cin >> N >> K;
for (int i = 0; i < N; ++i)
cin >> h[i];
for (int i = 0; i < 110000; ++i)
dp[i] = INF;
dp[0] = 0;
for (int i = 0; i < N; ++i) {
for (int j = 1; j <= K; ++j) {
dp[i] = min(dp[i + j], dp[i] + abs(h[i] - h[i + j]));
}
}
cout << dp[N - 1] << endl;
} | #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
const long long INF = 1LL << 60;
int N;
long long h[110000];
long long dp[110000];
int main() {
int N, K;
cin >> N >> K;
for (int i = 0; i < N; ++i)
cin >> h[i];
for (int i = 0; i < 110000; ++i)
dp[i] = INF;
dp[0] = 0;
for (int i = 0; i < N; ++i) {
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;
} | [
"assignment.change"
] | 959,563 | 959,564 | u447096097 | cpp |
p03161 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
long long MOD = 1000000007LL;
int main() {
int N, K;
cin >> N >> K;
vector<long long> H(N);
for (int i = 0; i < N; ++i) {
cin >> H[i];
}
vector<long long> costmap(N);
costmap[0] = 0;
costmap[1] = abs(H[1] - H[0]);
int X = 2;
for (; X < N; ++X) {
costmap[X] = 10000;
for (int i = X - 1; max(X - K, 0) <= i; --i) {
costmap[X] = min(abs(H[X] - H[i]) + costmap[i], costmap[X]);
}
}
cout << costmap[N - 1] << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
long long MOD = 1000000007LL;
int main() {
int N, K;
cin >> N >> K;
vector<long long> H(N);
for (int i = 0; i < N; ++i) {
cin >> H[i];
}
vector<long long> costmap(N);
costmap[0] = 0;
costmap[1] = abs(H[1] - H[0]);
int X = 2;
for (; X < N; ++X) {
costmap[X] = 1ll << 60;
for (int i = X - 1; max(X - K, 0) <= i; --i) {
costmap[X] = min(abs(H[X] - H[i]) + costmap[i], costmap[X]);
}
}
cout << costmap[N - 1] << endl;
return 0;
}
| [
"literal.number.change",
"assignment.value.change",
"assignment.change"
] | 959,565 | 959,566 | u055685044 | cpp |
p03161 | #include <iostream>
#include <vector>
using namespace std;
int min(int &a, int &b) { return a < b ? a : b; }
void pre_calc(int n, int k, vector<int> &V, vector<int> &dp) {
dp[0] = 0;
for (int i = 1; i < n; i++) {
for (int j = 1; j <= k; j++) {
int pos = i - j;
if (pos < 0)
break;
dp[i] = min(dp[i], dp[pos] + abs(V[i] - V[pos]));
}
}
}
int main() {
int N, K;
vector<int> V;
vector<int> dp;
cin >> N >> K;
V.assign(N, 0);
dp.assign(N, INT16_MAX);
for (int i = 0; i < N; i++)
cin >> V[i];
pre_calc(N, K, V, dp);
cout << dp[N - 1] << endl;
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
int min(int &a, int &b) { return a < b ? a : b; }
void pre_calc(int n, int k, vector<int> &V, vector<int> &dp) {
dp[0] = 0;
for (int i = 1; i < n; i++) {
for (int j = 1; j <= k; j++) {
int pos = i - j;
if (pos < 0)
break;
dp[i] = min(dp[i], dp[pos] + abs(V[i] - V[pos]));
}
}
}
int main() {
int N, K;
vector<int> V;
vector<int> dp;
cin >> N >> K;
V.assign(N, 0);
dp.assign(N, INT32_MAX);
for (int i = 0; i < N; i++)
cin >> V[i];
pre_calc(N, K, V, dp);
cout << dp[N - 1] << endl;
return 0;
} | [
"identifier.change",
"call.arguments.change"
] | 959,577 | 959,578 | u358037627 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
#define f first
#define s second
typedef long long int ll;
const int N = 1e5 + 5, M = 1e4 + 5;
int n, k, a[N], memo[N][105];
int solve(int ind, int c) {
if (~memo[ind][c])
return memo[ind][c];
if (ind == n - 1)
return memo[ind][c] = abs(a[ind] - a[ind - c]);
if (c == k)
return memo[ind][c] = abs(a[ind] - a[ind - c]) + solve(ind + 1, 1);
if (!c)
return memo[ind][c] = solve(ind + 1, 1);
return memo[ind][c] = min(abs(a[ind] - a[ind - 1]) + solve(ind + 1, 1),
solve(ind + 1, c + 1));
}
int main() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
memset(memo, -1, sizeof memo);
cin >> n >> k;
for (int i = 0; i < n; i++)
cin >> a[i];
cout << solve(0, 0) << '\n';
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define f first
#define s second
typedef long long int ll;
const int N = 1e5 + 5, M = 1e4 + 5;
int n, k, a[N], memo[N][105];
int solve(int ind, int c) {
if (~memo[ind][c])
return memo[ind][c];
if (ind == n - 1)
return memo[ind][c] = abs(a[ind] - a[ind - c]);
if (c == k)
return memo[ind][c] = abs(a[ind] - a[ind - c]) + solve(ind + 1, 1);
if (!c)
return memo[ind][c] = solve(ind + 1, 1);
return memo[ind][c] = min(abs(a[ind] - a[ind - c]) + solve(ind + 1, 1),
solve(ind + 1, c + 1));
}
int main() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
memset(memo, -1, sizeof memo);
cin >> n >> k;
for (int i = 0; i < n; i++)
cin >> a[i];
cout << solve(0, 0) << '\n';
return 0;
}
| [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"call.arguments.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 959,579 | 959,580 | u445305910 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
long long h[n], a[n];
for (int i = 0; i < n; i++) {
cin >> h[i];
}
a[0] = 0;
a[1] = abs(h[0] - h[1]);
for (long long i = 2; i < k; i++) {
long long s = INT_MAX;
for (long long j = 1; j <= i; j++) {
s = min(s, a[i - j] + abs(h[i] - h[i - j]));
}
a[i] = s;
}
for (long long i = k; i < n; i++) {
long long s = INT_MAX;
for (long long j = 1; j <= k; j++) {
s = min(s, a[i - j] + abs(h[i] - h[i - j]));
}
a[i] = s;
}
cout << a[n - 1] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
long long h[n], a[n];
for (int i = 0; i < n; i++) {
cin >> h[i];
}
a[0] = 0;
a[1] = abs(h[0] - h[1]);
for (long long i = 2; i < min(n, k); i++) {
long long s = INT_MAX;
for (long long j = 1; j <= i; j++) {
s = min(s, a[i - j] + abs(h[i] - h[i - j]));
}
a[i] = s;
}
for (long long i = k; i < n; i++) {
long long s = INT_MAX;
for (long long j = 1; j <= k; j++) {
s = min(s, a[i - j] + abs(h[i] - h[i - j]));
}
a[i] = s;
}
cout << a[n - 1] << endl;
return 0;
}
| [
"control_flow.loop.for.condition.change",
"call.add",
"call.arguments.change"
] | 959,581 | 959,582 | u746339181 | cpp |
p03161 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define _upgrade \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define pb push_back
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
// ****************************************CODE***************************************//
int n, k;
int h[110000];
int dp[110000];
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> h[i];
}
for (int i = 0; i < 110000; i++) {
dp[i] = inf;
}
dp[0] = 0;
for (int i = 0; i < n; i++) {
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 <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define _upgrade \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define pb push_back
// ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
// ll lcm(ll x, ll y) {return x / gcd(x, y) * y;}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
const ll inf = 1LL << 60;
const long double pi = 3.14159265358979323846;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
// ****************************************CODE***************************************//
int n, k;
int h[110000];
ll dp[110000];
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> h[i];
}
for (int i = 0; i < 110000; i++) {
dp[i] = inf;
}
dp[0] = 0;
for (int i = 0; i < n; i++) {
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;
} | [
"variable_declaration.type.change"
] | 959,583 | 959,584 | u195054737 | cpp |
p03161 | #include <iostream>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int h[100000];
int dp[100000];
for (int i = 0; i < n; i++) {
cin >> h[i];
dp[i] = 100000;
}
dp[0] = 0;
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];
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int h[100000];
int dp[100000];
for (int i = 0; i < n; i++) {
cin >> h[i];
dp[i] = 1000000000;
}
dp[0] = 0;
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];
return 0;
}
| [
"literal.number.change",
"assignment.value.change"
] | 959,592 | 959,593 | u195054737 | cpp |
p03161 | #include <bits/stdc++.h>
#include <stdio.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define all(v) ((v).begin()), ((v).end())
#define rall(v) ((v).rbegin()), ((v).rend())
#define clr(v, line) memset(v, line, sizeof(v))
#define endl '\n'
#define TRACE
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *coma = strchr(names + 1, ',');
cerr.write(names, coma - names) << " : " << arg1 << " | ";
__f(coma + 1, args...);
}
#else
#define trace(...)
#endif
void file() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
void fast() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
}
int N, k;
std::vector<int> dp(100005, INT_MAX), h;
int main(int argc, char const *argv[]) {
file();
fast();
cin >> N >> k;
h.resize(N);
for (int i = 0; i < N; ++i) {
cin >> h[i];
}
dp[0] = 0;
for (int i = 0; i < N; ++i) {
for (int j = 1; j <= min(k, N - i); ++j) {
dp[i + j] = min(dp[i + j], dp[i] + abs(h[i] - h[i + j]));
}
}
cout << dp[N - 1];
} | #include <bits/stdc++.h>
#include <stdio.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define all(v) ((v).begin()), ((v).end())
#define rall(v) ((v).rbegin()), ((v).rend())
#define clr(v, line) memset(v, line, sizeof(v))
#define endl '\n'
#define TRACE
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *coma = strchr(names + 1, ',');
cerr.write(names, coma - names) << " : " << arg1 << " | ";
__f(coma + 1, args...);
}
#else
#define trace(...)
#endif
void file() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
void fast() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
}
int N, k;
std::vector<int> dp(100005, INT_MAX), h;
int main(int argc, char const *argv[]) {
// file();
fast();
cin >> N >> k;
h.resize(N);
for (int i = 0; i < N; ++i) {
cin >> h[i];
}
dp[0] = 0;
for (int i = 0; i < N; ++i) {
for (int j = 1; j <= min(k, N - i); ++j) {
dp[i + j] = min(dp[i + j], dp[i] + abs(h[i] - h[i + j]));
}
}
cout << dp[N - 1];
} | [
"call.remove"
] | 959,602 | 959,603 | u555865264 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
int mem[100050];
int main()
{
int a[100050];
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++)
cin >> a[i];
mem[n - 1] = abs(a[n] - a[n - 1]);
mem[n] = 0;
for (int i = n - 2; i > 0; i--) {
mem[i] = 100050;
for (int j = 1; j <= k; j++) {
if ((i + j) > n)
break;
mem[i] = min(mem[i], abs(a[i + j] - a[i]) + mem[i + j]);
}
}
cout << mem[1];
} | #include <bits/stdc++.h>
using namespace std;
int mem[100050];
int main()
{
int a[100050];
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++)
cin >> a[i];
mem[n - 1] = abs(a[n] - a[n - 1]);
mem[n] = 0;
for (int i = n - 2; i > 0; i--) {
mem[i] = INT_MAX;
for (int j = 1; j <= k; j++) {
if ((i + j) > n)
break;
mem[i] = min(mem[i], abs(a[i + j] - a[i]) + mem[i + j]);
}
}
cout << mem[1];
} | [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 959,604 | 959,605 | u202518254 | cpp |
p03161 | #include <algorithm>
#include <cstdint>
#include <iostream>
int const NMAX = 100000;
int n, k;
uint32_t h[NMAX];
uint32_t dp[NMAX];
void read() {
std::cin >> n;
std::cin >> k;
for (int i = 0; i < n; ++i)
std::cin >> h[i];
}
inline uint32_t iabs(int x) { return x < 0 ? -x : x; }
void calc() {
dp[0] = 0;
dp[1] = iabs(h[1] - h[0]);
for (int i = 2; i < n; ++i) {
dp[i] = dp[i - 1] + iabs(h[i] - h[i - 1]);
for (int j = 2; j <= k; ++j) {
dp[i] = std::min(dp[i - j] + iabs(h[i] - h[i - j]), dp[i]);
}
}
}
int main() {
read();
calc();
std::cout << dp[n - 1] << std::endl;
return 0;
}
| #include <algorithm>
#include <cstdint>
#include <iostream>
int const NMAX = 100000;
int n, k;
uint32_t h[NMAX];
uint32_t dp[NMAX];
void read() {
std::cin >> n;
std::cin >> k;
for (int i = 0; i < n; ++i)
std::cin >> h[i];
}
inline uint32_t iabs(int x) { return x < 0 ? -x : x; }
void calc() {
dp[0] = 0;
dp[1] = iabs(h[1] - h[0]);
for (int i = 2; i < n; ++i) {
dp[i] = dp[i - 1] + iabs(h[i] - h[i - 1]);
for (int j = 2; j <= k && j <= i; ++j) {
dp[i] = std::min(dp[i - j] + iabs(h[i] - h[i - j]), dp[i]);
}
}
}
int main() {
read();
calc();
std::cout << dp[n - 1] << std::endl;
return 0;
}
| [
"control_flow.loop.for.condition.change"
] | 959,606 | 959,607 | u294638337 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define stuff \
ios::sync_with_stdio(0); \
cin.tie(0)
#define INF 100007
ll abso(ll x) { return (x > 0) ? x : -1 * x; }
int main() {
stuff;
ll n, k;
cin >> n >> k;
ll h[n], dp[n];
for (ll i = 0; i < n; i++)
dp[i] = INF;
for (ll i = 0; i < n; i++)
cin >> h[i];
dp[0] = 0;
// cout<<"yes"<<dp[4]<<endl;
for (ll i = 0; i < n; ++i) {
for (ll j = i + 1; j <= i + k; ++j) {
if (j < n) {
dp[j] = min(dp[j], dp[i] + abso(h[i] - h[j]));
// cout<<dp[j]<<endl;
}
}
}
cout << dp[n - 1] << "\n";
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define stuff \
ios::sync_with_stdio(0); \
cin.tie(0)
#define INF 1e9 + 5
ll abso(ll x) { return (x > 0) ? x : -1 * x; }
int main() {
stuff;
ll n, k;
cin >> n >> k;
ll h[n], dp[n];
for (ll i = 0; i < n; i++)
dp[i] = INF;
for (ll i = 0; i < n; i++)
cin >> h[i];
dp[0] = 0;
// cout<<"yes"<<dp[4]<<endl;
for (ll i = 0; i < n; ++i) {
for (ll j = i + 1; j <= i + k; ++j) {
if (j < n) {
dp[j] = min(dp[j], dp[i] + abso(h[i] - h[j]));
// cout<<dp[j]<<endl;
}
}
}
cout << dp[n - 1] << "\n";
return 0;
}
| [
"preprocessor.define.value.change",
"literal.float.change"
] | 959,608 | 959,609 | u564037510 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
int INF = 256;
cin >> N >> K;
vector<int> H(N);
vector<int> dp(N, INF);
for (int i = 0; i < N; i++)
cin >> H.at(i);
dp.at(0) = 0;
for (int i = 1; i < N; i++) {
for (int j = 1; j < min(K, i) + 1; j++) {
dp.at(i) = min(dp.at(i), dp.at(i - j) + abs(H.at(i) - H.at(i - j)));
}
}
cout << dp.at(N - 1) << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
int INF = INT_MAX;
cin >> N >> K;
vector<int> H(N);
vector<int> dp(N, INF);
for (int i = 0; i < N; i++)
cin >> H.at(i);
dp.at(0) = 0;
for (int i = 1; i < N; i++) {
for (int j = 1; j < min(K, i) + 1; j++) {
dp.at(i) = min(dp.at(i), dp.at(i - j) + abs(H.at(i) - H.at(i - j)));
}
}
cout << dp.at(N - 1) << endl;
} | [
"variable_declaration.value.change",
"identifier.replace.add",
"literal.replace.remove"
] | 959,612 | 959,613 | u627325970 | cpp |
p03161 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const long long INF = 1LL << 60;
#define rep(i, e) for (int i = 0; i < e; i++)
#define repp(i, s, e) for (int i = s; i < e; i++)
#define N_Max 100
#define Card_Max 36
#define p(a) printf("%d\n", a);
#define ll long long
#define ull unsigned long long
#define MAX 100005
#define NIL -1
int main() {
int N, K;
ll h[100005] = {};
ll dp[100005] = {};
cin >> N >> K;
rep(i, N) cin >> h[i];
dp[0] = 0;
ll minv;
repp(i, 1, K) {
minv = MAX;
rep(j, i) { minv = min(minv, dp[j] + abs(h[i] - h[j])); }
dp[i] = minv;
}
repp(i, K, N) {
minv = MAX;
repp(j, i - K, i) {
minv = min(minv, dp[j] + abs(h[i] - h[j]));
// cout << "i: " << i << endl;
// cout << "j: " << j << endl;
// cout << "dp[j]: " << dp[j] << endl;
// cout << "h[i]: " << h[i] << endl;
// cout << "h[j]: " << h[j] << endl;
// cout << "minv: " << minv << endl;
}
dp[i] = minv;
}
// rep(i,N){
// cout << dp[i] << endl;
// }
cout << dp[N - 1] << endl;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const long long INF = 1LL << 60;
#define rep(i, e) for (int i = 0; i < e; i++)
#define repp(i, s, e) for (int i = s; i < e; i++)
#define N_Max 100
#define Card_Max 36
#define p(a) printf("%d\n", a);
#define ll long long
#define ull unsigned long long
#define MAX 1e9
#define NIL -1
int main() {
int N, K;
ll h[100005] = {};
ll dp[100005] = {};
cin >> N >> K;
rep(i, N) cin >> h[i];
dp[0] = 0;
ll minv;
repp(i, 1, K) {
minv = MAX;
rep(j, i) { minv = min(minv, dp[j] + abs(h[i] - h[j])); }
dp[i] = minv;
}
repp(i, K, N) {
minv = MAX;
repp(j, i - K, i) {
minv = min(minv, dp[j] + abs(h[i] - h[j]));
// cout << "i: " << i << endl;
// cout << "j: " << j << endl;
// cout << "dp[j]: " << dp[j] << endl;
// cout << "h[i]: " << h[i] << endl;
// cout << "h[j]: " << h[j] << endl;
// cout << "minv: " << minv << endl;
}
dp[i] = minv;
}
// rep(i,N){
// cout << dp[i] << endl;
// }
cout << dp[N - 1] << endl;
}
| [
"preprocessor.define.value.change",
"literal.float.change"
] | 959,614 | 959,615 | u159695843 | cpp |
p03161 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const long long INF = 1LL << 60;
#define rep(i, e) for (int i = 0; i < e; i++)
#define repp(i, s, e) for (int i = s; i < e; i++)
#define N_Max 100
#define Card_Max 36
#define p(a) printf("%d\n", a);
#define ll long long
#define ull unsigned long long
#define MAX 100005
#define NIL -1
int main() {
int N, K;
int h[100005] = {};
int dp[100005] = {};
cin >> N >> K;
rep(i, N) cin >> h[i];
dp[0] = 0;
int minv;
repp(i, 1, K) {
minv = MAX;
rep(j, i) { minv = min(minv, dp[j] + abs(h[i] - h[j])); }
dp[i] = minv;
}
repp(i, K, N) {
minv = MAX;
repp(j, i - K, i) {
minv = min(minv, dp[j] + abs(h[i] - h[j]));
// cout << "i: " << i << endl;
// cout << "j: " << j << endl;
// cout << "dp[j]: " << dp[j] << endl;
// cout << "h[i]: " << h[i] << endl;
// cout << "h[j]: " << h[j] << endl;
// cout << "minv: " << minv << endl;
}
dp[i] = minv;
}
// rep(i,N){
// cout << dp[i] << endl;
// }
cout << dp[N - 1] << endl;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const long long INF = 1LL << 60;
#define rep(i, e) for (int i = 0; i < e; i++)
#define repp(i, s, e) for (int i = s; i < e; i++)
#define N_Max 100
#define Card_Max 36
#define p(a) printf("%d\n", a);
#define ll long long
#define ull unsigned long long
#define MAX 1e9
#define NIL -1
int main() {
int N, K;
ll h[100005] = {};
ll dp[100005] = {};
cin >> N >> K;
rep(i, N) cin >> h[i];
dp[0] = 0;
ll minv;
repp(i, 1, K) {
minv = MAX;
rep(j, i) { minv = min(minv, dp[j] + abs(h[i] - h[j])); }
dp[i] = minv;
}
repp(i, K, N) {
minv = MAX;
repp(j, i - K, i) {
minv = min(minv, dp[j] + abs(h[i] - h[j]));
// cout << "i: " << i << endl;
// cout << "j: " << j << endl;
// cout << "dp[j]: " << dp[j] << endl;
// cout << "h[i]: " << h[i] << endl;
// cout << "h[j]: " << h[j] << endl;
// cout << "minv: " << minv << endl;
}
dp[i] = minv;
}
// rep(i,N){
// cout << dp[i] << endl;
// }
cout << dp[N - 1] << endl;
}
| [
"preprocessor.define.value.change",
"literal.float.change",
"variable_declaration.type.change"
] | 959,616 | 959,615 | u159695843 | cpp |
p03161 | #include <cmath>
#include <iostream>
using namespace std;
static const int MAX_N = 100000;
static const int MAX_h = 10000;
int main(void) {
int n, k;
int H[MAX_N];
cin >> n;
cin >> k;
for (int i = 0; i < n; i++) {
cin >> H[i];
}
// dp[i][j]は足場i-jから足場iに移る場合のiまでの最小コスト
int dp[n][k];
for (int i = 0; i < n; i++) {
for (int j = 0; j < k; j++) {
dp[i][j] = MAX_h;
}
}
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < k; j++) {
for (int bfj = 0; bfj < k; bfj++) {
// 0スタートなのに1スタートで考えてたi-jをi-j-1に変換し忘れていた
if ((dp[i][j] > dp[i - j - 1][bfj] + abs(H[i - j - 1] - H[i])) &&
i - j > 0) {
dp[i][j] = dp[i - j - 1][bfj] + abs(H[i - j - 1] - H[i]);
}
}
}
}
// cout << dp[0][0] << "\n";
// ansを探す
int ans = MAX_h;
for (int j = 0; j < k; j++) {
if (ans > dp[n - 1][j])
ans = dp[n - 1][j];
}
cout << ans;
return 0;
} | #include <cmath>
#include <iostream>
using namespace std;
static const int MAX_N = 100000;
static const int MAX_h = 100000000000;
int main(void) {
int n, k;
int H[MAX_N];
cin >> n;
cin >> k;
for (int i = 0; i < n; i++) {
cin >> H[i];
}
// dp[i][j]は足場i-jから足場iに移る場合のiまでの最小コスト
int dp[n][k];
for (int i = 0; i < n; i++) {
for (int j = 0; j < k; j++) {
dp[i][j] = MAX_h;
}
}
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < k; j++) {
for (int bfj = 0; bfj < k; bfj++) {
// 0スタートなのに1スタートで考えてたi-jをi-j-1に変換し忘れていた
if ((dp[i][j] > dp[i - j - 1][bfj] + abs(H[i - j - 1] - H[i])) &&
i - j > 0) {
dp[i][j] = dp[i - j - 1][bfj] + abs(H[i - j - 1] - H[i]);
}
}
}
}
// cout << dp[0][0] << "\n";
// ansを探す
int ans = MAX_h;
for (int j = 0; j < k; j++) {
if (ans > dp[n - 1][j])
ans = dp[n - 1][j];
}
cout << ans;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 959,622 | 959,621 | u900688325 | cpp |
p03161 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define int long long
#define str string
#define rtn return
#define pb push_back
#define db long double
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
const int N = 1e5 + 7;
int dp[N];
int h[N];
int n, k;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i < n; i++)
dp[i] = N;
for (int i = 0; i < n; i++)
cin >> h[i];
for (int i = 1; i < n; i++) {
for (int j = 1; j <= k; j++) {
if (i - j >= 0) {
dp[i] = min(dp[i], dp[i - j] + abs(h[i] - h[i - j]));
}
}
// cout << dp[i] << endl;
}
cout << dp[n - 1] << "\n";
return 0;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define int long long
#define str string
#define rtn return
#define pb push_back
#define db long double
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
const int N = 1e5 + 7;
int dp[N];
int h[N];
int n, k;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i < n; i++)
dp[i] = 1e9;
for (int i = 0; i < n; i++)
cin >> h[i];
for (int i = 1; i < n; i++) {
for (int j = 1; j <= k; j++) {
if (i - j >= 0) {
dp[i] = min(dp[i], dp[i - j] + abs(h[i] - h[i - j]));
}
}
// cout << dp[i] << endl;
}
cout << dp[n - 1] << "\n";
return 0;
} | [
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add"
] | 959,623 | 959,624 | u640997954 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define out(ans) cout << ans << endl
#define in(n) cin >> n
#define floop(i, N) for (ll i = 0; i < N; i++)
#define floop1(i, N) for (ll i = 1; i <= N; i++)
#define floopi(i, j, N) for (ll j = i + 1; j < N; j++)
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;
}
constexpr ll inf = 1e18;
void solve();
int main() { solve(); }
void solve() {
ll n, k;
in(n);
in(k);
ll h[n];
floop(i, n) in(h[i]);
ll dp[n];
floop(i, n) dp[i] = inf;
dp[0] = 0;
floop(i, n) {
floop1(j, k) { chmin(dp[i + j], dp[i] + abs(h[i] - h[i + j])); }
}
out(dp[n - 1]);
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define out(ans) cout << ans << endl
#define in(n) cin >> n
#define floop(i, N) for (ll i = 0; i < N; i++)
#define floop1(i, N) for (ll i = 1; i <= N; i++)
#define floopi(i, j, N) for (ll j = i + 1; j < N; j++)
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;
}
constexpr ll inf = 1e18;
void solve();
int main() { solve(); }
void solve() {
ll n, k;
in(n);
in(k);
ll h[n];
floop(i, n) in(h[i]);
ll dp[n + k];
floop(i, n + k) dp[i] = inf;
dp[0] = 0;
floop(i, n) {
floop1(j, k) { chmin(dp[i + j], dp[i] + abs(h[i] - h[i + j])); }
}
out(dp[n - 1]);
} | [
"assignment.change"
] | 959,636 | 959,637 | u789673251 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define out(ans) cout << ans << endl
#define in(n) cin >> n
#define floop(i, N) for (ll i = 0; i < N; i++)
#define floop1(i, N) for (ll i = 1; i <= N; i++)
#define floopi(i, j, N) for (ll j = i + 1; j < N; j++)
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;
}
constexpr ll inf = 1e18;
void solve();
int main() { solve(); }
void solve() {
ll n, k;
in(n);
in(k);
ll h[n];
floop(i, n) in(h[i]);
ll dp[n];
floop(i, n) dp[i] = inf;
dp[0] = 0;
floop(i, n) {
floop1(j, k) { chmin(dp[i + j], dp[i] + abs(h[i] - h[i + j])); }
}
out(dp[n - 1]);
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define out(ans) cout << ans << endl
#define in(n) cin >> n
#define floop(i, N) for (ll i = 0; i < N; i++)
#define floop1(i, N) for (ll i = 1; i <= N; i++)
#define floopi(i, j, N) for (ll j = i + 1; j < N; j++)
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;
}
constexpr ll inf = 1e18;
void solve();
int main() { solve(); }
void solve() {
ll n, k;
in(n);
in(k);
ll h[n];
floop(i, n) in(h[i]);
ll dp[110000];
floop(i, 110000) dp[i] = inf;
dp[0] = 0;
floop(i, n) {
floop1(j, k) { chmin(dp[i + j], dp[i] + abs(h[i] - h[i + j])); }
}
out(dp[n - 1]);
} | [
"identifier.replace.remove",
"literal.replace.add",
"variable_declaration.array_dimensions.change",
"assignment.variable.change",
"call.arguments.change"
] | 959,636 | 959,638 | u789673251 | cpp |
p03161 | #include <bits/stdc++.h>
#include <cmath>
#include <iostream>
#include <string>
using namespace std;
#define ll long long
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define FOR(i, a, b) for (ll i = (a); i < (b); i++)
#define FORR(i, a, b) for (ll i = (a); i <= (b); i++)
#define repR(i, n) for (ll i = n; i >= 0; i--)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define F first
#define S second
#define pb push_back
#define pu push
#define COUT(x) cout << (x) << endl
#define PQ priority_queue<ll>
#define PQR priority_queue<ll, vector<ll>, greater<ll>>
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
#define mp make_pair
#define maxs(x, y) (x = max(x, y))
#define mins(x, y) (x = min(x, y))
#define sz(x) (int)(x).size()
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const ll MOD = 1000000007LL;
const ll INF = 1LL << 60;
using vll = vector<ll>;
using vb = vector<bool>;
using vvb = vector<vb>;
using vvll = vector<vll>;
using vstr = vector<string>;
using pll = pair<ll, ll>;
using vc = vector<char>;
using vvc = vector<vc>;
ll dx[4] = {0, 1, 0, -1};
ll dy[4] = {1, 0, -1, 0};
int main() {
ll n, k;
cin >> n >> k;
vll h(n);
rep(i, n) cin >> h[i];
vll dp(n, INF);
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < min(n, k + i + 1); j++) {
dp[j] = min(dp[j], dp[i] + abs(h[i] - h[j]));
}
}
COUT(dp[4]);
}
| #include <bits/stdc++.h>
#include <cmath>
#include <iostream>
#include <string>
using namespace std;
#define ll long long
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define FOR(i, a, b) for (ll i = (a); i < (b); i++)
#define FORR(i, a, b) for (ll i = (a); i <= (b); i++)
#define repR(i, n) for (ll i = n; i >= 0; i--)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define F first
#define S second
#define pb push_back
#define pu push
#define COUT(x) cout << (x) << endl
#define PQ priority_queue<ll>
#define PQR priority_queue<ll, vector<ll>, greater<ll>>
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
#define mp make_pair
#define maxs(x, y) (x = max(x, y))
#define mins(x, y) (x = min(x, y))
#define sz(x) (int)(x).size()
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const ll MOD = 1000000007LL;
const ll INF = 1LL << 60;
using vll = vector<ll>;
using vb = vector<bool>;
using vvb = vector<vb>;
using vvll = vector<vll>;
using vstr = vector<string>;
using pll = pair<ll, ll>;
using vc = vector<char>;
using vvc = vector<vc>;
ll dx[4] = {0, 1, 0, -1};
ll dy[4] = {1, 0, -1, 0};
int main() {
ll n, k;
cin >> n >> k;
vll h(n);
rep(i, n) cin >> h[i];
vll dp(n, INF);
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < min(n, k + i + 1); j++) {
dp[j] = min(dp[j], dp[i] + abs(h[i] - h[j]));
}
}
COUT(dp[n - 1]);
}
| [
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"call.arguments.change"
] | 959,681 | 959,682 | u103850114 | cpp |
p03161 | #include <bits/stdc++.h>
#include <cmath>
#include <iostream>
#include <string>
using namespace std;
#define ll long long
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define FOR(i, a, b) for (ll i = (a); i < (b); i++)
#define FORR(i, a, b) for (ll i = (a); i <= (b); i++)
#define repR(i, n) for (ll i = n; i >= 0; i--)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define F first
#define S second
#define pb push_back
#define pu push
#define COUT(x) cout << (x) << endl
#define PQ priority_queue<ll>
#define PQR priority_queue<ll, vector<ll>, greater<ll>>
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
#define mp make_pair
#define maxs(x, y) (x = max(x, y))
#define mins(x, y) (x = min(x, y))
#define sz(x) (int)(x).size()
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const ll MOD = 1000000007LL;
const ll INF = 1LL << 60;
using vll = vector<ll>;
using vb = vector<bool>;
using vvb = vector<vb>;
using vvll = vector<vll>;
using vstr = vector<string>;
using pll = pair<ll, ll>;
using vc = vector<char>;
using vvc = vector<vc>;
ll dx[4] = {0, 1, 0, -1};
ll dy[4] = {1, 0, -1, 0};
int main() {
ll n, k;
cin >> n >> k;
vll h(n);
rep(i, n) cin >> h[i];
vll dp(n, INF);
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < min(n, k + i); j++) {
dp[j] = min(dp[j], dp[i] + abs(h[i] - h[j]));
}
}
COUT(dp[n - 1]);
} | #include <bits/stdc++.h>
#include <cmath>
#include <iostream>
#include <string>
using namespace std;
#define ll long long
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define FOR(i, a, b) for (ll i = (a); i < (b); i++)
#define FORR(i, a, b) for (ll i = (a); i <= (b); i++)
#define repR(i, n) for (ll i = n; i >= 0; i--)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define F first
#define S second
#define pb push_back
#define pu push
#define COUT(x) cout << (x) << endl
#define PQ priority_queue<ll>
#define PQR priority_queue<ll, vector<ll>, greater<ll>>
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
#define mp make_pair
#define maxs(x, y) (x = max(x, y))
#define mins(x, y) (x = min(x, y))
#define sz(x) (int)(x).size()
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const ll MOD = 1000000007LL;
const ll INF = 1LL << 60;
using vll = vector<ll>;
using vb = vector<bool>;
using vvb = vector<vb>;
using vvll = vector<vll>;
using vstr = vector<string>;
using pll = pair<ll, ll>;
using vc = vector<char>;
using vvc = vector<vc>;
ll dx[4] = {0, 1, 0, -1};
ll dy[4] = {1, 0, -1, 0};
int main() {
ll n, k;
cin >> n >> k;
vll h(n);
rep(i, n) cin >> h[i];
vll dp(n, INF);
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < min(n, k + i + 1); j++) {
dp[j] = min(dp[j], dp[i] + abs(h[i] - h[j]));
}
}
COUT(dp[n - 1]);
}
| [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 959,683 | 959,682 | u103850114 | cpp |
p03161 | #include <bits/stdc++.h>
#define forn(i, n) for (int i = 0; i < (int)n; ++i)
#define fi first
#define se second
#define for1(i, n) for (int i = 1; i <= (int)n; ++i)
#define fore(i, l, r) for (int i = (int)l; i <= (int)r; ++i)
#define ford(i, n) for (int i = (int)(n)-1; i >= 0; --i)
#define fored(i, l, r) for (int i = (int)r; i >= (int)l; --i)
#define pb push_back
#define el '\n'
#define d(x) cout << #x << " " << x << el
#define ri(n) scanf("%d", &n)
#define __USE_MINGW_ANSI_STDIO 0
using namespace std;
typedef long long ll;
typedef pair<int, int> ii;
typedef pair<char, int> pci;
typedef tuple<int, int, int> tiii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
// const ll INF = LONG_LONG_MAX;
const double PI = acos(-1);
const int MAXN = 1e5 + 200;
const double EPS = 1e-10;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, k;
cin >> n >> k;
int dp[n];
int a[n];
forn(i, n) { cin >> a[i]; }
dp[0] = 0;
dp[1] = abs(a[0] - a[1]);
// dp[2]=abs(a[0]-a[2]);
for (int i = 2; i < n; ++i) {
int mini = MAXN;
for1(j, min(k, i)) { mini = min(mini, dp[i - j] + abs(a[i - j] - a[i])); }
dp[i] = mini;
}
cout << dp[n - 1];
}
| #include <bits/stdc++.h>
#define forn(i, n) for (int i = 0; i < (int)n; ++i)
#define fi first
#define se second
#define for1(i, n) for (int i = 1; i <= (int)n; ++i)
#define fore(i, l, r) for (int i = (int)l; i <= (int)r; ++i)
#define ford(i, n) for (int i = (int)(n)-1; i >= 0; --i)
#define fored(i, l, r) for (int i = (int)r; i >= (int)l; --i)
#define pb push_back
#define el '\n'
#define d(x) cout << #x << " " << x << el
#define ri(n) scanf("%d", &n)
#define __USE_MINGW_ANSI_STDIO 0
using namespace std;
typedef long long ll;
typedef pair<int, int> ii;
typedef pair<char, int> pci;
typedef tuple<int, int, int> tiii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
// const ll INF = LONG_LONG_MAX;
const double PI = acos(-1);
const int MAXN = 1e9 + 200;
const double EPS = 1e-10;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, k;
cin >> n >> k;
int dp[n];
int a[n];
forn(i, n) { cin >> a[i]; }
dp[0] = 0;
dp[1] = abs(a[0] - a[1]);
// dp[2]=abs(a[0]-a[2]);
for (int i = 2; i < n; ++i) {
int mini = MAXN;
for1(j, min(k, i)) { mini = min(mini, dp[i - j] + abs(a[i - j] - a[i])); }
dp[i] = mini;
}
cout << dp[n - 1];
}
| [
"literal.number.change",
"expression.operation.binary.change"
] | 959,690 | 959,691 | u118290687 | 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 dp[100];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
vector<int> h(n);
rep(i, n) cin >> h[i];
rep(i, 100) dp[i] = 1e6;
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= k; j++) {
if (i - j >= 0) {
dp[i] = min(dp[i], dp[i - j] + abs(h[i] - h[i - j]));
} else {
break;
}
}
}
cout << dp[n - 1] << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)n; i++)
typedef long long ll;
int dp[100010];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
vector<int> h(n);
rep(i, n) cin >> h[i];
rep(i, 100010) dp[i] = 1e9;
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= k; j++) {
if (i - j >= 0) {
dp[i] = min(dp[i], dp[i - j] + abs(h[i] - h[i - j]));
} else {
break;
}
}
}
cout << dp[n - 1] << endl;
}
| [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"assignment.variable.change",
"call.arguments.change",
"assignment.value.change"
] | 959,696 | 959,697 | u862412671 | cpp |
p03161 | #include <iostream>
using namespace std;
const int INF = 114514;
int h[100005];
int dp[100005];
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> h[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)
break;
dp[i + j] = min(dp[i + j], dp[i] + abs(h[i + j] - h[i]));
}
}
cout << dp[n - 1] << endl;
}
| #include <iostream>
using namespace std;
const long long INF = 1145141919810;
int h[100005];
long long dp[100005];
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> h[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)
break;
dp[i + j] = min(dp[i + j], dp[i] + abs(h[i + j] - h[i]));
}
}
cout << dp[n - 1] << endl;
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"literal.number.change",
"variable_declaration.value.change"
] | 959,712 | 959,713 | u590427200 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repr(i, n) for (int i = (int)(n); i >= 0; i--)
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); i++)
#define all(v) v.begin(), v.end()
typedef long long ll;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const long long INF = 1LL << 60;
int N;
long long h[100010];
long long dp[100010];
int main() {
int N, K;
cin >> N >> K;
rep(i, N) cin >> h[i];
rep(i, N) dp[i] = INF;
dp[0] = 0;
rep(i, N) {
rep(j, K) if (i - j >= 0) {
chmin(dp[i], dp[i - j - 1] + abs(h[i] - h[i - j - 1]));
}
}
cout << dp[N - 1] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repr(i, n) for (int i = (int)(n); i >= 0; i--)
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); i++)
#define all(v) v.begin(), v.end()
typedef long long ll;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const long long INF = 1LL << 60;
int N;
long long h[100010];
long long dp[100010];
int main() {
int N, K;
cin >> N >> K;
rep(i, N) cin >> h[i];
rep(i, N) dp[i] = INF;
dp[0] = 0;
rep(i, N) {
rep(j, K) if (i - j - 1 >= 0) {
chmin(dp[i], dp[i - j - 1] + abs(h[i] - h[i - j - 1]));
}
}
cout << dp[N - 1] << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 959,722 | 959,723 | u328179672 | cpp |
p03161 | // includes
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
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;
}
// macros and consts
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define all(a) (a).begin(), (a).end()
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define FORE(i, a) for (auto &i : a)
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define accm accumulate
#define Fi first
#define Se second
#define INF 1e9
#define llINF (1LL << 60)
#define mINF -1e9
#define mllINF -(1LL << 60)
#define endl "\n"
#define CONT continue
#define BRK break
#define modulo(n, m) (((n) % (m) + (m)) % m)
// shorter types
using namespace std;
using ll = long long;
using vi = std::vector<int>;
using vc = std::vector<char>;
using vll = std::vector<long long>;
using vs = std::vector<string>;
using Mi = map<int, int>;
using Mll = map<ll, ll>;
using UMi = unordered_map<int, int>;
using UMll = unordered_map<ll, ll>;
using Pi = pair<int, int>;
using Pll = pair<ll, ll>;
using vPi = vector<Pi>;
using vPll = vector<Pll>;
using vvi = vector<vector<int>>;
using vvll = vector<vector<ll>>;
using vvc = vector<vector<char>>;
using vvs = vector<vector<string>>;
using pqgi = priority_queue<int, vector<int>, greater<int>>;
using pqsi = priority_queue<int, vector<int>, less<int>>;
using pqgll = priority_queue<int, vector<int>, greater<int>>;
using pssll = priority_queue<int, vector<int>, less<int>>;
template <class T> using vec = vector<T>;
#define int long long
int N;
int K;
// here begins your code
signed main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
vector<int> h;
cin >> N;
cin >> K;
h.resize(N);
REP(i, N) { cin >> h[i]; }
vector<int> dp;
dp.resize(N + 10, llINF);
dp[0] = 0;
for (int i = 0; i < N; i++) {
for (int j = 1; j <= K; j++) {
chmin(dp[i + j], dp[i] + abs(h[i + j] - h[i]));
}
}
cout << dp[N - 1] << endl;
// check types
// do not eb if you resize
// resize before you access by idx
return 0;
} | // includes
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
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;
}
// macros and consts
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define all(a) (a).begin(), (a).end()
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define FORE(i, a) for (auto &i : a)
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define accm accumulate
#define Fi first
#define Se second
#define INF 1e9
#define llINF (1LL << 60)
#define mINF -1e9
#define mllINF -(1LL << 60)
#define endl "\n"
#define CONT continue
#define BRK break
#define modulo(n, m) (((n) % (m) + (m)) % m)
// shorter types
using namespace std;
using ll = long long;
using vi = std::vector<int>;
using vc = std::vector<char>;
using vll = std::vector<long long>;
using vs = std::vector<string>;
using Mi = map<int, int>;
using Mll = map<ll, ll>;
using UMi = unordered_map<int, int>;
using UMll = unordered_map<ll, ll>;
using Pi = pair<int, int>;
using Pll = pair<ll, ll>;
using vPi = vector<Pi>;
using vPll = vector<Pll>;
using vvi = vector<vector<int>>;
using vvll = vector<vector<ll>>;
using vvc = vector<vector<char>>;
using vvs = vector<vector<string>>;
using pqgi = priority_queue<int, vector<int>, greater<int>>;
using pqsi = priority_queue<int, vector<int>, less<int>>;
using pqgll = priority_queue<int, vector<int>, greater<int>>;
using pssll = priority_queue<int, vector<int>, less<int>>;
template <class T> using vec = vector<T>;
#define int long long
int N;
int K;
// here begins your code
signed main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
vector<int> h;
cin >> N;
cin >> K;
h.resize(N);
REP(i, N) { cin >> h[i]; }
vector<int> dp;
dp.resize(N + 110, llINF);
dp[0] = 0;
for (int i = 0; i < N; i++) {
for (int j = 1; j <= K; j++) {
chmin(dp[i + j], dp[i] + abs(h[i + j] - h[i]));
}
}
cout << dp[N - 1] << endl;
// check types
// do not eb if you resize
// resize before you access by idx
return 0;
} | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 959,724 | 959,725 | u193690465 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, k;
cin >> n >> k;
vector<int> h(n);
for (int i = 0; i < n; i++) {
cin >> h[i];
}
vector<int> dp(n);
dp[0] = 0;
dp[1] = abs(h[1] - h[0]);
if (n == 2) {
cout << dp[1] << endl;
return 0;
}
for (int i = 2; i < n; i++) {
int tmp = dp[i - 1] + abs(h[i] - h[i - 1]);
for (int j = 2; j <= min(n, k); j++) {
tmp = min(tmp, dp[i - j] + abs(h[i] - h[i - j]));
}
dp[i] = tmp;
}
cout << dp.back() << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, k;
cin >> n >> k;
vector<int> h(n);
for (int i = 0; i < n; i++) {
cin >> h[i];
}
vector<int> dp(n);
dp[0] = 0;
dp[1] = abs(h[1] - h[0]);
if (n == 2) {
cout << dp[1] << endl;
return 0;
}
for (int i = 2; i < n; i++) {
int tmp = dp[i - 1] + abs(h[i] - h[i - 1]);
for (int j = 2; j <= min(i, k); j++) {
tmp = min(tmp, dp[i - j] + abs(h[i] - h[i - j]));
}
dp[i] = tmp;
}
cout << dp.back() << endl;
return 0;
}
| [
"identifier.change",
"control_flow.loop.for.condition.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 959,730 | 959,731 | u302818391 | cpp |
p03161 | #include <iomanip>
#include <iostream>
#include <queue>
#include <stack>
#include <stdlib.h>
#include <string>
#include <vector>
using namespace std;
int main(int argc, char const *argv[]) {
int n, k;
cin >> n >> k;
int *h = new int[n];
int *dp = new int[n];
for (int i = 0; i < n; i++) {
cin >> h[i];
dp[i] = 0;
}
for (int i = 1; i < n; i++) {
int temp = INT32_MAX;
for (int j = 1; j <= n and i - j >= 0; j++) {
temp = (dp[i - j] + abs(h[i] - h[i - j])) < temp
? (dp[i - j] + abs(h[i] - h[i - j]))
: temp;
}
dp[i] = temp;
}
cout << dp[n - 1] << endl;
delete[] h;
delete[] dp;
return 0;
}
| #include <iomanip>
#include <iostream>
#include <queue>
#include <stack>
#include <stdlib.h>
#include <string>
#include <vector>
using namespace std;
int main(int argc, char const *argv[]) {
int n, k;
cin >> n >> k;
int *h = new int[n];
int *dp = new int[n];
for (int i = 0; i < n; i++) {
cin >> h[i];
dp[i] = 0;
}
for (int i = 1; i < n; i++) {
int temp = INT32_MAX;
for (int j = 1; j <= k and i - j >= 0; j++) {
temp = (dp[i - j] + abs(h[i] - h[i - j])) < temp
? (dp[i - j] + abs(h[i] - h[i - j]))
: temp;
}
dp[i] = temp;
}
cout << dp[n - 1] << endl;
delete[] h;
delete[] dp;
return 0;
}
| [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 959,732 | 959,733 | u534223360 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V> void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T> void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x)
cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V> void _print(T t, V... v) {
__print(t);
if (sizeof...(v))
cerr << ", ";
_print(v...);
}
#ifndef ONLINE_JUDGE
#define debug(x...) \
cerr << "[" << #x << "] = ["; \
_print(x)
#else
#define debug(x...)
#endif
#define forn(i, n) for (int i = 0; i < n; i++)
#define forw(i, w) for (int i = n; i >= 0; i--)
#define dforn(i, a, b) for (int i = a; i < b; i++)
#define dforw(i, b, a) for (int i = b; i >= a; i--)
#define read(v) \
for (auto &i : v) \
cin >> i;
#define all(v) v.begin(), v.end()
typedef long long ll;
typedef vector<int> vi;
typedef vector<double> vd;
typedef pair<int, int> pii;
int n, k;
vi arr, dp;
int main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
cin >> n >> k;
arr.assign(n, 0);
dp.assign(n, 99999);
dp[0] = 0;
read(arr);
forn(i, n) for (int j = i + 1; j < n && j < i + k + 1; j++) dp[j] =
min(dp[j], dp[i] + abs(arr[j] - arr[i]));
cout << dp[n - 1] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V> void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T> void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x)
cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V> void _print(T t, V... v) {
__print(t);
if (sizeof...(v))
cerr << ", ";
_print(v...);
}
#ifndef ONLINE_JUDGE
#define debug(x...) \
cerr << "[" << #x << "] = ["; \
_print(x)
#else
#define debug(x...)
#endif
#define forn(i, n) for (int i = 0; i < n; i++)
#define forw(i, w) for (int i = n; i >= 0; i--)
#define dforn(i, a, b) for (int i = a; i < b; i++)
#define dforw(i, b, a) for (int i = b; i >= a; i--)
#define read(v) \
for (auto &i : v) \
cin >> i;
#define all(v) v.begin(), v.end()
typedef long long ll;
typedef vector<int> vi;
typedef vector<double> vd;
typedef pair<int, int> pii;
int n, k;
vi arr, dp;
int main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
cin >> n >> k;
arr.assign(n, 0);
dp.assign(n, 999999999);
dp[0] = 0;
read(arr);
forn(i, n) for (int j = i + 1; j < n && j < i + k + 1; j++) dp[j] =
min(dp[j], dp[i] + abs(arr[j] - arr[i]));
cout << dp[n - 1] << endl;
return 0;
} | [
"literal.number.change",
"call.arguments.change"
] | 959,734 | 959,735 | u170622357 | cpp |
p03161 | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repi(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
const int INF = 1e5;
int main() {
int N, K;
cin >> N >> K;
vector<int> h(N);
rep(i, N) { cin >> h[i]; }
vector<int> dp(N);
dp[1] = abs(h[1] - h[0]);
repi(i, 2, N) {
int min_cost = INF;
repi(j, 1, min(i + 1, K + 1)) {
int cost = dp[i - j] + abs(h[i] - h[i - j]);
if (cost < min_cost) {
min_cost = cost;
}
}
dp[i] = min_cost;
}
cout << dp[N - 1] << endl;
}
| #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repi(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
const int INF = 1e9;
int main() {
int N, K;
cin >> N >> K;
vector<int> h(N);
rep(i, N) { cin >> h[i]; }
vector<int> dp(N);
dp[1] = abs(h[1] - h[0]);
repi(i, 2, N) {
int min_cost = INF;
repi(j, 1, min(i + 1, K + 1)) {
int cost = dp[i - j] + abs(h[i] - h[i - j]);
if (cost < min_cost) {
min_cost = cost;
}
}
dp[i] = min_cost;
}
cout << dp[N - 1] << endl;
}
| [
"literal.number.change",
"variable_declaration.value.change"
] | 959,738 | 959,739 | u811967730 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int64_t abs(int64_t n) {
if (n < 0) {
n = -n;
}
return n;
}
int main() {
int n, k;
cin >> n >> k;
vector<int> h(n);
rep(i, n) { cin >> h.at(i); }
vector<int64_t> dp((int)pow(10, 5) + 10, (int)pow(10, 16) + 10);
dp.at(0) = 0;
for (int i = 1; i < n; i++) {
chmin(dp.at(i), dp.at(i - 1) + abs(h.at(i) - h.at(i - 1)));
if (i - k >= 0) {
for (int j = 0; j < k; j++) {
chmin(dp.at(i), dp.at(i - 1 - j) + abs(h.at(i) - h.at(i - 1 - j)));
}
} else {
for (int j = 0; j <= i - 1; j++) {
chmin(dp.at(i), dp.at(i - 1 - j) + abs(h.at(i) - h.at(i - 1 - j)));
}
}
}
cout << dp.at(n - 1) << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int64_t abs(int64_t n) {
if (n < 0) {
n = -n;
}
return n;
}
int main() {
int n, k;
cin >> n >> k;
vector<int> h(n);
rep(i, n) { cin >> h.at(i); }
vector<int64_t> dp((int)pow(10, 5) + 10, (int)pow(10, 9) + 10);
dp.at(0) = 0;
for (int i = 1; i < n; i++) {
chmin(dp.at(i), dp.at(i - 1) + abs(h.at(i) - h.at(i - 1)));
if (i - k >= 0) {
for (int j = 0; j < k; j++) {
chmin(dp.at(i), dp.at(i - 1 - j) + abs(h.at(i) - h.at(i - 1 - j)));
}
} else {
for (int j = 0; j <= i - 1; j++) {
chmin(dp.at(i), dp.at(i - 1 - j) + abs(h.at(i) - h.at(i - 1 - j)));
}
}
}
cout << dp.at(n - 1) << endl;
} | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 959,742 | 959,743 | u785492958 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
int n, k;
int a[100000];
int dp[100000];
int recur(int i) {
if (i == n - 1)
return 0;
if (dp[i] != -1)
return dp[i];
else {
dp[i] = recur(i + 1) + abs(a[i] - a[i + 1]);
for (int j = 2; j <= k; j++) {
if (i + j < n) {
dp[i] = min(dp[i], recur(i + j) + abs(a[i] - a[j]));
}
}
return dp[i];
}
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++)
cin >> a[i];
memset(dp, -1, sizeof dp);
cout << recur(0);
}
| #include <bits/stdc++.h>
using namespace std;
int n, k;
int a[100000];
int dp[100000];
int recur(int i) {
if (i == n - 1)
return 0;
if (dp[i] != -1)
return dp[i];
else {
dp[i] = recur(i + 1) + abs(a[i] - a[i + 1]);
for (int j = 2; j <= k; j++) {
if (i + j < n) {
dp[i] = min(dp[i], recur(i + j) + abs(a[i] - a[i + j]));
}
}
return dp[i];
}
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++)
cin >> a[i];
memset(dp, -1, sizeof dp);
cout << recur(0);
}
| [
"assignment.change"
] | 959,745 | 959,746 | u083367057 | cpp |
p03161 | // https://atcoder.jp/contests/dp/tasks/dp_b
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define REPL(i, n) for (ll i = 0, i##_len = (n); i < i##_len; ++i)
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define radrad(a) 180.0 * a / M_PI
#define pow(x) x *x
static const int MAX = 10010;
static const ll INFTY = 1e12;
static const ll NUMMAX = 1000000007;
static const ll MOD = 1000000007;
#define LOOP 10000000
// 四方向への移動ベクトル
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
// 入力
int H, W;
vector<string> field;
int result = 100;
int dfs_res = 0;
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() {
int N, K;
cin >> N >> K;
vector<int> h(N);
vector<int> dp(N + 1, MAX);
REP(i, N) { cin >> h[i]; }
int sum = 0;
dp[0] = 0;
for (int i = 1; i < N; i++) {
if (i == 1) {
dp[i] = abs(h[i] - h[i - 1]);
} else {
for (int j = 1; j <= K; j++) {
dp[i] = min(dp[i], abs(h[i] - h[i - j]) + dp[i - j]);
if (j == i)
break;
}
}
// cout << h[i] << " " << h[i-1] << " ";
// cout << dp[i] << " ";
}
cout << dp[N - 1] << endl;
return 0;
}
/*
_ooOoo_
o8888888o
88" . "88
(| -_- |)
O\ = /O
____/`---'\____
.' \\| |// `.
/ \\||| : |||// \
/ _||||| -:- |||||- \
| | \\\ - /// | |
| \_| ''\---/'' | |
\ .-\__ `-` ___/-. /
___`. .' /--.--\ `. . __
."" '< `.___\_<|>_/___.' >'"".
| | : `- \`.;`\ _ /`;.`/ - ` : | |
\ \ `-. \_ __\ /__ _/ .-` / /
======`-.____`-.___\_____/___.-`____.-'======
`=---='
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
pass System Test!
*/
| // https://atcoder.jp/contests/dp/tasks/dp_b
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define REPL(i, n) for (ll i = 0, i##_len = (n); i < i##_len; ++i)
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define radrad(a) 180.0 * a / M_PI
#define pow(x) x *x
static const int MAX = 1000010;
static const ll INFTY = 1e12;
static const ll NUMMAX = 1000000007;
static const ll MOD = 1000000007;
#define LOOP 10000000
// 四方向への移動ベクトル
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
// 入力
int H, W;
vector<string> field;
int result = 100;
int dfs_res = 0;
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() {
int N, K;
cin >> N >> K;
vector<ll> h(N);
vector<ll> dp(N + 1, INFTY);
REP(i, N) { cin >> h[i]; }
int sum = 0;
dp[0] = 0;
for (int i = 1; i < N; i++) {
if (i == 1) {
dp[i] = abs(h[i] - h[i - 1]);
} else {
for (int j = 1; j <= K; j++) {
dp[i] = min(dp[i], abs(h[i] - h[i - j]) + dp[i - j]);
if (j == i)
break;
}
}
// cout << h[i] << " " << h[i-1] << " ";
// cout << dp[i] << " ";
}
cout << dp[N - 1] << endl;
return 0;
}
/*
_ooOoo_
o8888888o
88" . "88
(| -_- |)
O\ = /O
____/`---'\____
.' \\| |// `.
/ \\||| : |||// \
/ _||||| -:- |||||- \
| | \\\ - /// | |
| \_| ''\---/'' | |
\ .-\__ `-` ___/-. /
___`. .' /--.--\ `. . __
."" '< `.___\_<|>_/___.' >'"".
| | : `- \`.;`\ _ /`;.`/ - ` : | |
\ \ `-. \_ __\ /__ _/ .-` / /
======`-.____`-.___\_____/___.-`____.-'======
`=---='
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
pass System Test!
*/
| [
"literal.number.change",
"variable_declaration.value.change",
"identifier.change",
"call.arguments.change"
] | 959,749 | 959,750 | u488878376 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
ll dp[100001], n, k;
ll solve(int arr[], int idx) {
if (idx >= n - 1)
return 0;
if (dp[idx] != -1)
return dp[idx];
dp[idx] = solve(arr, idx + 1) + abs(arr[idx] - arr[idx + 1]);
for (int i = idx + 1; i <= idx + k; i++)
dp[idx] = min(dp[idx], abs(arr[i] - arr[idx]) + solve(arr, i));
return dp[idx];
}
int main() {
cin >> n >> k;
int arr[n];
for (int i = 0; i < n; i++)
cin >> arr[i];
memset(dp, -1, sizeof(dp));
cout << solve(arr, 0);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
ll dp[100001], n, k;
ll solve(int arr[], int idx) {
if (idx >= n - 1)
return 0;
if (dp[idx] != -1)
return dp[idx];
dp[idx] = solve(arr, idx + 1) + abs(arr[idx] - arr[idx + 1]);
for (int i = idx + 1; i <= idx + k && i < n; i++)
dp[idx] = min(dp[idx], abs(arr[i] - arr[idx]) + solve(arr, i));
return dp[idx];
}
int main() {
cin >> n >> k;
int arr[n];
for (int i = 0; i < n; i++)
cin >> arr[i];
memset(dp, -1, sizeof(dp));
cout << solve(arr, 0);
return 0;
}
| [
"control_flow.loop.for.condition.change"
] | 959,761 | 959,762 | u423214530 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace ::std;
typedef long long lint;
typedef long long ll;
typedef long double ldouble;
typedef vector<lint> vec;
typedef vector<vector<lint>> mat;
typedef vector<vector<vector<lint>>> mat3;
typedef vector<double> dvec;
typedef vector<vector<double>> dmat;
typedef vector<vector<vector<double>>> dmat3;
typedef vector<string> svec;
typedef vector<vector<string>> smat;
typedef vector<vector<vector<string>>> smat3;
#define rep(i, n) for (lint i = 0; i < (lint)(n); i++)
#define irep(i) for (lint i = 0;; i++)
#define irep1(i) for (lint i = 1;; i++)
#define irep2(i) for (lint i = 2;; i++)
#define rrep(i, n) for (lint i = (lint)(n - 1); i > -1; i--)
#define rrepi(i, a, b) for (lint i = (lint)(b - 1); i > a - 1; i--)
#define repi(i, a, b) for (lint i = lint(a); i < lint(b); i++)
#define rep2(i, a, b, c) for (lint i = lint(a); i > lint(b); i += c)
#define all(x) (x).begin(), (x).end()
#define sl(c) (('a') <= (c) && (c) <= ('z'))
#define ll(c) (('A') <= (c) && (c) <= ('Z'))
#define max3(a, b, c) max(a, max(b, c))
#define min3(a, b, c) min(a, min(b, c))
#define PI 3.141592653589793
#define cout (cout << fixed << setprecision(15))
#define makeupper(t) (transform(all(t), t.begin(), ::toupper))
#define makelower(t) (transform(all(t), t.begin(), ::tolower))
#define dist(x1, y1, x2, y2) (pow(pow(x2 - x1, 2) + pow(y2 - y1, 2), 0.5))
#define NEXT_LINE \
string junk; \
getline(cin, junk);
#define output(v) \
do { \
rep(i, v.size()) cout << (i ? " " : "") << v[i]; \
cout << "\n"; \
} while (0)
#define output2(v) \
rep(i, v.size()) { \
rep(j, v[i].size()) { cout << (j ? " " : "") << v[i][j]; } \
cout << "\n"; \
}
#define INF 1LL << 60
#define IINF 1 << 30
#define LINF 9223372036854775807
#define MOD 998244353
vector<lint> dx = {-1, 1, 0, 0, 1, 1, -1, -1};
vector<lint> dy = {0, 0, -1, 1, 1, -1, 1, -1};
vector<lint> operator+(const vector<lint> &v1, const vector<lint> &v2) {
vector<lint> v(v1.size() + v2.size(), 0);
rep(i, v1.size()) v[i] = v1[i];
rep(i, v2.size()) v[i + v1.size()] = v2[i];
return v;
}
inline lint sum(vector<lint> v) {
lint sum = 0;
rep(i, v.size()) sum += v[i];
return sum;
}
inline string replace(string str, string before, std::string after) {
string::size_type Pos(str.find(before));
while (Pos != std::string::npos) {
str.replace(Pos, before.length(), after);
Pos = str.find(before, Pos + after.length());
}
return str;
}
inline vector<string> split(string s, string delim) {
vector<string> elems;
s = replace(s, "#", "HASH");
s = replace(s, delim, "#");
stringstream ss(s);
string item;
while (getline(ss, item, '#')) {
elems.push_back(replace(item, "HASH", "#"));
}
return elems;
}
inline vector<int> cross(vector<int> a, vector<int> b) {
return {a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2],
a[0] * b[1] - a[1] * b[0]};
}
inline lint GCD(lint a, lint b) { return b ? GCD(b, a % b) : a; }
inline vector<lint> primeList(lint n) {
vector<bool> p(n + 1);
vector<lint> list;
repi(i, 1, n + 1) p[i] = true;
repi(i, 2, sqrt(n) + 1) {
if (p[i]) {
repi(j, 2, n / i + 1) { p[i * j] = false; }
}
}
repi(i, 2, n + 1) if (p[i]) list.push_back(i);
return list;
}
inline set<lint> primeSet(lint n) {
vector<bool> p(n + 1);
set<lint> set;
repi(i, 1, n + 1) p[i] = true;
repi(i, 2, sqrt(n) + 1) {
if (p[i]) {
repi(j, 2, n / i + 1) { p[i * j] = false; }
}
}
repi(i, 2, n + 1) if (p[i]) set.insert(i);
return set;
}
inline bool isPrime(int num) {
if (num < 2)
return false;
else if (num == 2)
return true;
else if (num % 2 == 0)
return false;
double sqrtNum = sqrt(num);
for (int i = 3; i <= sqrtNum; i += 2) {
if (num % i == 0)
return false;
}
return true;
}
inline lint max(vector<lint> num) {
lint M = num[0];
rep(i, num.size()) M = max(M, num[i]);
return M;
}
inline lint min(vector<lint> num) {
lint M = num[0];
rep(i, num.size()) M = min(M, num[i]);
return M;
}
inline lint signal(lint val) {
if (val == 0)
return 0;
else
return val / abs(val);
}
struct IVector2 {
lint x, y;
};
bool operator<(const IVector2 &s, const IVector2 &t) {
return s.x == t.x ? s.y < t.y : s.x < t.x;
};
bool operator>(const IVector2 &s, const IVector2 &t) {
return s.x == t.x ? s.y > t.y : s.x > t.x;
};
struct IVector3 {
lint x, y, z;
};
struct IVector4 {
lint x, y, z, w;
};
template <typename... args> struct dfs {
public:
queue<function<void(void)>> que;
function<void(args..., dfs<args...> &)> func;
void run() {
while (!que.empty()) {
que.front()();
que.pop();
}
}
void push(args... arg) { que.push(bind(func, arg..., ref(*this))); }
dfs(args... init, function<void(args..., dfs<args...> &)> func) : func(func) {
push(init...);
run();
}
};
lint mod_pow(lint x, lint y, lint mod) {
if (y == 0)
return 1;
else if (y == 1)
return x;
else if (y % 2 == 1)
return x * mod_pow(x, y - 1, mod) % mod;
else
return mod_pow(x, y / 2, mod) * mod_pow(x, y / 2, mod) % mod;
}
lint binary_search(function<bool(lint)> func) {
lint left = -1;
lint right = IINF;
while (right - left > 1) {
lint mid = left + (right - left) / 2;
if (func(mid))
right = mid;
else
left = mid;
}
return right;
}
std::string RLE(string str) {
string result = "";
char cmp = str[0];
lint cnt = 0;
rep(i, str.length()) {
if (cmp == str[i]) {
cnt++;
} else {
result += cmp;
result += cnt;
cnt = 0;
cmp = str[i];
}
}
}
lint habs(lint h1, lint h2) {
if (h1 > h2)
return h1 - h2;
else
return h2 - h1;
}
int main(void) {
lint n, k;
cin >> n >> k;
vec h(n);
vec dp(n);
rep(i, n) { cin >> h[i]; }
rep(i, n) { dp[i] = INF; }
dp[0] = 0;
dp[1] = habs(h[0], h[1]);
rep(i, n - 1) {
for (lint j = 1; j < k; j++) {
if (i + j < n && dp[i] + habs(h[i], h[i + j]) < dp[i + j]) {
dp[i + j] = dp[i] + habs(h[i], h[i + j]);
}
}
}
cout << dp[n - 1];
}
| #include <bits/stdc++.h>
using namespace ::std;
typedef long long lint;
typedef long long ll;
typedef long double ldouble;
typedef vector<lint> vec;
typedef vector<vector<lint>> mat;
typedef vector<vector<vector<lint>>> mat3;
typedef vector<double> dvec;
typedef vector<vector<double>> dmat;
typedef vector<vector<vector<double>>> dmat3;
typedef vector<string> svec;
typedef vector<vector<string>> smat;
typedef vector<vector<vector<string>>> smat3;
#define rep(i, n) for (lint i = 0; i < (lint)(n); i++)
#define irep(i) for (lint i = 0;; i++)
#define irep1(i) for (lint i = 1;; i++)
#define irep2(i) for (lint i = 2;; i++)
#define rrep(i, n) for (lint i = (lint)(n - 1); i > -1; i--)
#define rrepi(i, a, b) for (lint i = (lint)(b - 1); i > a - 1; i--)
#define repi(i, a, b) for (lint i = lint(a); i < lint(b); i++)
#define rep2(i, a, b, c) for (lint i = lint(a); i > lint(b); i += c)
#define all(x) (x).begin(), (x).end()
#define sl(c) (('a') <= (c) && (c) <= ('z'))
#define ll(c) (('A') <= (c) && (c) <= ('Z'))
#define max3(a, b, c) max(a, max(b, c))
#define min3(a, b, c) min(a, min(b, c))
#define PI 3.141592653589793
#define cout (cout << fixed << setprecision(15))
#define makeupper(t) (transform(all(t), t.begin(), ::toupper))
#define makelower(t) (transform(all(t), t.begin(), ::tolower))
#define dist(x1, y1, x2, y2) (pow(pow(x2 - x1, 2) + pow(y2 - y1, 2), 0.5))
#define NEXT_LINE \
string junk; \
getline(cin, junk);
#define output(v) \
do { \
rep(i, v.size()) cout << (i ? " " : "") << v[i]; \
cout << "\n"; \
} while (0)
#define output2(v) \
rep(i, v.size()) { \
rep(j, v[i].size()) { cout << (j ? " " : "") << v[i][j]; } \
cout << "\n"; \
}
#define INF 1LL << 60
#define IINF 1 << 30
#define LINF 9223372036854775807
#define MOD 998244353
vector<lint> dx = {-1, 1, 0, 0, 1, 1, -1, -1};
vector<lint> dy = {0, 0, -1, 1, 1, -1, 1, -1};
vector<lint> operator+(const vector<lint> &v1, const vector<lint> &v2) {
vector<lint> v(v1.size() + v2.size(), 0);
rep(i, v1.size()) v[i] = v1[i];
rep(i, v2.size()) v[i + v1.size()] = v2[i];
return v;
}
inline lint sum(vector<lint> v) {
lint sum = 0;
rep(i, v.size()) sum += v[i];
return sum;
}
inline string replace(string str, string before, std::string after) {
string::size_type Pos(str.find(before));
while (Pos != std::string::npos) {
str.replace(Pos, before.length(), after);
Pos = str.find(before, Pos + after.length());
}
return str;
}
inline vector<string> split(string s, string delim) {
vector<string> elems;
s = replace(s, "#", "HASH");
s = replace(s, delim, "#");
stringstream ss(s);
string item;
while (getline(ss, item, '#')) {
elems.push_back(replace(item, "HASH", "#"));
}
return elems;
}
inline vector<int> cross(vector<int> a, vector<int> b) {
return {a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2],
a[0] * b[1] - a[1] * b[0]};
}
inline lint GCD(lint a, lint b) { return b ? GCD(b, a % b) : a; }
inline vector<lint> primeList(lint n) {
vector<bool> p(n + 1);
vector<lint> list;
repi(i, 1, n + 1) p[i] = true;
repi(i, 2, sqrt(n) + 1) {
if (p[i]) {
repi(j, 2, n / i + 1) { p[i * j] = false; }
}
}
repi(i, 2, n + 1) if (p[i]) list.push_back(i);
return list;
}
inline set<lint> primeSet(lint n) {
vector<bool> p(n + 1);
set<lint> set;
repi(i, 1, n + 1) p[i] = true;
repi(i, 2, sqrt(n) + 1) {
if (p[i]) {
repi(j, 2, n / i + 1) { p[i * j] = false; }
}
}
repi(i, 2, n + 1) if (p[i]) set.insert(i);
return set;
}
inline bool isPrime(int num) {
if (num < 2)
return false;
else if (num == 2)
return true;
else if (num % 2 == 0)
return false;
double sqrtNum = sqrt(num);
for (int i = 3; i <= sqrtNum; i += 2) {
if (num % i == 0)
return false;
}
return true;
}
inline lint max(vector<lint> num) {
lint M = num[0];
rep(i, num.size()) M = max(M, num[i]);
return M;
}
inline lint min(vector<lint> num) {
lint M = num[0];
rep(i, num.size()) M = min(M, num[i]);
return M;
}
inline lint signal(lint val) {
if (val == 0)
return 0;
else
return val / abs(val);
}
struct IVector2 {
lint x, y;
};
bool operator<(const IVector2 &s, const IVector2 &t) {
return s.x == t.x ? s.y < t.y : s.x < t.x;
};
bool operator>(const IVector2 &s, const IVector2 &t) {
return s.x == t.x ? s.y > t.y : s.x > t.x;
};
struct IVector3 {
lint x, y, z;
};
struct IVector4 {
lint x, y, z, w;
};
template <typename... args> struct dfs {
public:
queue<function<void(void)>> que;
function<void(args..., dfs<args...> &)> func;
void run() {
while (!que.empty()) {
que.front()();
que.pop();
}
}
void push(args... arg) { que.push(bind(func, arg..., ref(*this))); }
dfs(args... init, function<void(args..., dfs<args...> &)> func) : func(func) {
push(init...);
run();
}
};
lint mod_pow(lint x, lint y, lint mod) {
if (y == 0)
return 1;
else if (y == 1)
return x;
else if (y % 2 == 1)
return x * mod_pow(x, y - 1, mod) % mod;
else
return mod_pow(x, y / 2, mod) * mod_pow(x, y / 2, mod) % mod;
}
lint binary_search(function<bool(lint)> func) {
lint left = -1;
lint right = IINF;
while (right - left > 1) {
lint mid = left + (right - left) / 2;
if (func(mid))
right = mid;
else
left = mid;
}
return right;
}
std::string RLE(string str) {
string result = "";
char cmp = str[0];
lint cnt = 0;
rep(i, str.length()) {
if (cmp == str[i]) {
cnt++;
} else {
result += cmp;
result += cnt;
cnt = 0;
cmp = str[i];
}
}
}
lint habs(lint h1, lint h2) {
if (h1 > h2)
return h1 - h2;
else
return h2 - h1;
}
int main(void) {
lint n, k;
cin >> n >> k;
vec h(n);
vec dp(n);
rep(i, n) { cin >> h[i]; }
rep(i, n) { dp[i] = INF; }
dp[0] = 0;
dp[1] = habs(h[0], h[1]);
rep(i, n - 1) {
for (lint j = 1; j <= k; j++) {
if (i + j < n && dp[i] + habs(h[i], h[i + j]) < dp[i + j]) {
dp[i + j] = dp[i] + habs(h[i], h[i + j]);
}
}
}
cout << dp[n - 1];
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 959,763 | 959,764 | u127065752 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define vi vector<long long>
#define endl "\n"
int main() {
ll n, k;
cin >> n >> k;
vi dp(n, INT_MAX), a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
dp[n - 1] = 0;
dp[n - 2] = abs(a[n - 1] - a[n - 2]);
// for(int i=n-3;i>=n-k;i--)
// {
// for(int j=i;j<n;j++)
// {
// dp[i]=min(dp[i],dp[j]+abs(a[i]-a[j]));
// }
// }
for (int i = n - 3; i >= 0; i--) {
for (int j = i + 1; j < i + k + 1; j++)
dp[i] = min(dp[i], dp[j] + abs(a[i] - a[j]));
}
cout << dp[0] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define vi vector<long long>
#define endl "\n"
int main() {
ll n, k;
cin >> n >> k;
vi dp(n, INT_MAX), a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
dp[n - 1] = 0;
dp[n - 2] = abs(a[n - 1] - a[n - 2]);
for (int i = n - 3; i >= 0; i--) {
for (int j = i + 1; j < i + k + 1 && j < n; j++)
dp[i] = min(dp[i], dp[j] + abs(a[i] - a[j]));
}
cout << dp[0] << endl;
return 0;
} | [
"control_flow.loop.for.condition.change"
] | 959,771 | 959,772 | u511499944 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
int n, k, a[100001], dp[100001];
int cal(int idx) {
if (idx == n)
return 0;
if (idx > n)
return 1e9;
if (dp[idx] != -1)
return dp[idx];
dp[idx] = 0;
for (int i = idx + 1; i <= idx + k; i++)
dp[idx] = min(dp[idx], cal(i) + abs(a[idx] - a[i]));
return dp[idx];
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++)
cin >> a[i];
for (int i = 1; i <= n; i++)
dp[i] = -1;
cout << cal(1);
}
| #include <bits/stdc++.h>
using namespace std;
int n, k, a[100001], dp[100001];
int cal(int idx) {
if (idx == n)
return 0;
if (idx > n)
return 1e9;
if (dp[idx] != -1)
return dp[idx];
dp[idx] = 1e9;
for (int i = idx + 1; i <= idx + k; i++)
dp[idx] = min(dp[idx], cal(i) + abs(a[idx] - a[i]));
return dp[idx];
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++)
cin >> a[i];
for (int i = 1; i <= n; i++)
dp[i] = -1;
cout << cal(1);
}
| [
"literal.number.change",
"assignment.value.change"
] | 959,785 | 959,786 | u848964569 | cpp |
p03161 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <iterator>
#include <map>
#include <sstream>
#include <stack>
#include <unordered_map>
#include <vector>
#define ll long long int
#define vi vector<long long int>
#define vvi vector<vll>
#define vs vector<string>
#define vsf v.begin(), v.end()
#define pb push_back
#define mp make_pair
using namespace std;
int main() {
ll i, n, s, j, k;
cin >> n >> k;
vi v(n), dp(n);
for (i = 0; i < n; i++)
cin >> v[i];
dp[0] = 0;
dp[1] = abs(v[1] - v[0]);
for (i = 2; i < n; i++) {
s = pow(10, 5);
for (j = i - 1; j >= max(i - i, i - k); j--)
s = min(s, dp[j] + abs(v[i] - v[j]));
dp[i] = s;
}
cout << dp[n - 1] << endl;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <iterator>
#include <map>
#include <sstream>
#include <stack>
#include <unordered_map>
#include <vector>
#define ll long long int
#define vi vector<long long int>
#define vvi vector<vll>
#define vs vector<string>
#define vsf v.begin(), v.end()
#define pb push_back
#define mp make_pair
using namespace std;
int main() {
ll i, n, s, j, k;
cin >> n >> k;
vi v(n), dp(n);
for (i = 0; i < n; i++)
cin >> v[i];
dp[0] = 0;
dp[1] = abs(v[1] - v[0]);
for (i = 2; i < n; i++) {
s = pow(10, 9);
for (j = i - 1; j >= max(i - i, i - k); j--)
s = min(s, dp[j] + abs(v[i] - v[j]));
dp[i] = s;
}
cout << dp[n - 1] << endl;
}
| [
"literal.number.change",
"assignment.value.change",
"call.arguments.change"
] | 959,787 | 959,788 | u163525690 | cpp |
p03161 | #include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <queue>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, k;
int a[100010];
int dp[100010] = {0};
int min = 1000000007;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
dp[1] = abs(a[1] - a[0]);
for (int j = 2; j < n; j++) {
for (int l = 1; l <= k; l++) {
if (n - l < 0) {
break;
}
if (abs(a[j] - a[j - l]) + dp[j - l] <= min) {
min = abs(a[j] - a[j - l]) + dp[j - l];
}
}
dp[j] = min;
min = 1000000007;
}
cout << dp[n - 1] << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <queue>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, k;
int a[100010];
int dp[100010] = {0};
int min = 1000000007;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
dp[1] = abs(a[1] - a[0]);
for (int j = 2; j < n; j++) {
for (int l = 1; l <= k; l++) {
if (j - l < 0) {
break;
}
if (abs(a[j] - a[j - l]) + dp[j - l] <= min) {
min = abs(a[j] - a[j - l]) + dp[j - l];
}
}
dp[j] = min;
min = 1000000007;
}
cout << dp[n - 1] << endl;
return 0;
} | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 959,794 | 959,795 | u003026289 | cpp |
p03161 | #include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <queue>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, k;
int a[100010];
int dp[100010] = {0};
int min = 1000000007;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
dp[1] = abs(a[1] - a[0]);
for (int j = 2; j < n; j++) {
for (int l = 1; l <= k; l++) {
if (l <= 0) {
break;
}
if (abs(a[j] - a[j - l]) + dp[j - l] <= min) {
min = abs(a[j] - a[j - l]) + dp[j - l];
}
}
dp[j] = min;
min = 1000000007;
}
cout << dp[n - 1] << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <queue>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, k;
int a[100010];
int dp[100010] = {0};
int min = 1000000007;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
dp[1] = abs(a[1] - a[0]);
for (int j = 2; j < n; j++) {
for (int l = 1; l <= k; l++) {
if (j - l < 0) {
break;
}
if (abs(a[j] - a[j - l]) + dp[j - l] <= min) {
min = abs(a[j] - a[j - l]) + dp[j - l];
}
}
dp[j] = min;
min = 1000000007;
}
cout << dp[n - 1] << endl;
return 0;
} | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"expression.operator.compare.change"
] | 959,797 | 959,795 | u003026289 | cpp |
p03161 | #include <cmath>
#include <iostream>
using namespace std;
int a[100010], f[100010];
int main() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++)
cin >> a[i];
f[1] = 0;
for (int i = 2; i <= n; i++) {
f[i] = 0x7fffffff;
for (int j = 1; j <= k; j++) {
if (i - j < 0)
break;
f[i] = min(f[i], f[i - j] + abs(a[i - j] - a[i]));
}
}
cout << f[n] << endl;
return 0;
}
| #include <cmath>
#include <iostream>
using namespace std;
int a[100010], f[100010];
int main() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++)
cin >> a[i];
f[1] = 0;
for (int i = 2; i <= n; i++) {
f[i] = 0x7fffffff;
for (int j = 1; j <= k; j++) {
if (i - j <= 0)
break;
f[i] = min(f[i], f[i - j] + abs(a[i - j] - a[i]));
}
}
cout << f[n] << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 959,800 | 959,801 | u052815054 | cpp |
p03161 | #include <algorithm>
#include <bits/stdc++.h>
#include <bitset>
#include <deque>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
#define N 40
#define K 300005
#define MOD 1e9 + 7
#define int long long
#define fastio \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
using namespace std;
int max(int a, int b) {
if (a > b)
return a;
return b;
}
int32_t main() {
int n, k;
cin >> n >> k;
int a[n + 1];
a[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
// exit(0);
int dp[n + 2];
dp[0] = 0;
dp[1] = 0;
for (int i = 2; i <= n; i++) {
int ans = INT_MAX;
for (int j = i - 1; j >= max(0, i - k); j--) {
ans = min(ans, dp[j] + abs(a[i] - a[j]));
}
dp[i] = ans;
// cout<<i<<" "<<dp[i]<<endl;
}
cout << dp[n] << endl;
} | #include <algorithm>
#include <bits/stdc++.h>
#include <bitset>
#include <deque>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
#define N 40
#define K 300005
#define MOD 1e9 + 7
#define int long long
#define fastio \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
using namespace std;
int max(int a, int b) {
if (a > b)
return a;
return b;
}
int32_t main() {
int n, k;
cin >> n >> k;
int a[n + 1];
a[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
// exit(0);
int dp[n + 2];
dp[0] = 0;
dp[1] = 0;
for (int i = 2; i <= n; i++) {
int ans = INT_MAX;
for (int j = i - 1; j >= max(1, i - k); j--) {
ans = min(ans, dp[j] + abs(a[i] - a[j]));
}
dp[i] = ans;
// cout<<i<<" "<<dp[i]<<endl;
}
cout << dp[n] << endl;
} | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"call.arguments.change",
"expression.operation.binary.change"
] | 959,802 | 959,803 | u269279722 | cpp |
p03161 | #include <math.h>
#include <stdio.h>
#include <stdlib.h>
int min(int n1, int n2) {
if (n1 > n2)
return n2;
else
return n1;
}
long int reach(int i, int a[], int memo[], int k) {
if (i < 2)
return 100000;
if (i == 2)
return 0;
if (memo[i] != -1)
return memo[i];
else {
int q = 100000, j, m;
if (k + 2 <= i)
m = k;
else
m = i - 2;
for (j = 1; j <= m; j++)
q = min(q, fabs(a[i] - a[i - j]) + reach(i - j, a, memo, k));
memo[i] = q;
return memo[i];
}
}
int main() {
int a[1000009], memo[1000009], n, k;
scanf("%d %d", &n, &k);
for (int i = 2; i <= n + 1; i++) {
scanf("%d", &a[i]);
memo[i] = -1;
}
printf("%ld\n", reach(n + 1, a, memo, k));
return 0;
}
| #include <math.h>
#include <stdio.h>
#include <stdlib.h>
int min(int n1, int n2) {
if (n1 > n2)
return n2;
else
return n1;
}
long int reach(int i, int a[], int memo[], int k) {
if (i < 2)
return 1000000000;
if (i == 2)
return 0;
if (memo[i] != -1)
return memo[i];
else {
long int q = 1000000000, j, m;
if (k + 2 <= i)
m = k;
else
m = i - 2;
for (j = 1; j <= m; j++)
q = min(q, fabs(a[i] - a[i - j]) + reach(i - j, a, memo, k));
memo[i] = q;
return memo[i];
}
}
int main() {
int a[1000009], memo[1000009], n, k;
scanf("%d %d", &n, &k);
for (int i = 2; i <= n + 1; i++) {
scanf("%d", &a[i]);
memo[i] = -1;
}
printf("%ld\n", reach(n + 1, a, memo, k));
return 0;
}
| [
"literal.number.change",
"function.return_value.change",
"variable_declaration.type.widen.change",
"variable_declaration.value.change"
] | 959,810 | 959,811 | u212014611 | cpp |
p03161 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep2(i, n) for (int i = 1; i < (n); ++i)
using namespace std;
typedef long long ll;
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const long long INF = 1LL << 60;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long h[100010];
long long dp[100010];
int N, K;
cin >> N >> K;
for (int i = 0; i < N; ++i)
cin >> h[i];
// 初期化 (最小化問題なので INF に初期化)
for (int i = 0; i < 110000; ++i)
dp[i] = INF;
// 初期条件
dp[0] = 0;
// ループ
rep(i, N) { rep2(j, K + 1) chmin(dp[i + j], dp[i] + abs(h[i] - h[i + j])); }
// 答え
cout << dp[N - 1] << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep2(i, n) for (int i = 1; i < (n); ++i)
using namespace std;
typedef long long ll;
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const long long INF = 1LL << 60;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long h[110000];
long long dp[110000];
int N, K;
cin >> N >> K;
for (int i = 0; i < N; ++i)
cin >> h[i];
// 初期化 (最小化問題なので INF に初期化)
for (int i = 0; i < 110000; ++i)
dp[i] = INF;
// 初期条件
dp[0] = 0;
// ループ
rep(i, N) { rep2(j, K + 1) chmin(dp[i + j], dp[i] + abs(h[i] - h[i + j])); }
// 答え
cout << dp[N - 1] << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 959,817 | 959,816 | u641446860 | cpp |
p03161 | #include <bits/stdc++.h>
#define int long long
using namespace std;
signed main() {
int N, K;
cin >> N, K;
int h[100010];
for (int i = 1; i <= N; i++) {
cin >> h[i];
}
int dp[10010];
for (int i = 1; i <= N; i++) {
dp[i] = 1e18;
}
dp[1] = 0;
for (int i = 1; i < N; i++) {
for (int j = 1; j <= K; j++) {
if (i + j > N) {
break;
} else {
dp[i + j] = min(dp[i + j], dp[i] + abs(h[i] - h[i + j]));
}
}
}
cout << dp[N] << endl;
} | #include <bits/stdc++.h>
#define int long long
using namespace std;
signed main() {
int N, K;
cin >> N >> K;
int h[100010];
for (int i = 1; i <= N; i++) {
cin >> h[i];
}
int dp[100010];
for (int i = 1; i <= N; i++) {
dp[i] = 1e18;
}
dp[1] = 0;
for (int i = 1; i < N; i++) {
for (int j = 1; j <= K; j++) {
if (i + j > N) {
break;
} else {
dp[i + j] = min(dp[i + j], dp[i] + abs(h[i] - h[i + j]));
}
}
}
cout << dp[N] << endl;
} | [
"literal.number.change",
"variable_declaration.array_dimensions.change"
] | 959,818 | 959,819 | u376649520 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, k;
cin >> n >> k;
int a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
int dp[n];
dp[0] = 0;
for (int i = 1; i < k; i++) {
int m = INT_MAX;
for (int j = 0; j < i; j++) {
m = min(dp[j] + abs(a[j] - a[i]), m);
}
dp[i] = m;
}
for (int i = k; i < n; i++) {
int m = INT_MAX;
for (int j = i - 1; i - j <= k; j--) {
m = min(dp[j] + abs(a[j] - a[i]), m);
}
dp[i] = m;
}
cout << dp[n - 1];
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, k;
cin >> n >> k;
int a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
int dp[n];
dp[0] = 0;
for (int i = 1; i < k && i < n; i++) {
int m = INT_MAX;
for (int j = 0; j < i; j++) {
m = min(dp[j] + abs(a[j] - a[i]), m);
}
dp[i] = m;
}
for (int i = k; i < n; i++) {
int m = INT_MAX;
for (int j = i - 1; i - j <= k; j--) {
m = min(dp[j] + abs(a[j] - a[i]), m);
}
dp[i] = m;
}
cout << dp[n - 1];
return 0;
} | [
"control_flow.loop.for.condition.change"
] | 959,824 | 959,825 | u356063349 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, k;
cin >> n >> k;
int a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
int dp[n];
dp[0] = 0;
for (int i = 1; i < k; i++) {
int m = INT_MAX;
for (int j = 0; j < i; j++) {
m = min(dp[j] + abs(a[j] - a[i]), m);
}
dp[i] = m;
}
for (int i = k; i < n; i++) {
int m = INT_MAX;
for (int j = i - 1; i - j <= k && j >= 0; j--) {
m = min(dp[j] + abs(a[j] - a[i]), m);
}
dp[i] = m;
}
cout << dp[n - 1];
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, k;
cin >> n >> k;
int a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
int dp[n];
dp[0] = 0;
for (int i = 1; i < k && i < n; i++) {
int m = INT_MAX;
for (int j = 0; j < i; j++) {
m = min(dp[j] + abs(a[j] - a[i]), m);
}
dp[i] = m;
}
for (int i = k; i < n; i++) {
int m = INT_MAX;
for (int j = i - 1; i - j <= k && j >= 0; j--) {
m = min(dp[j] + abs(a[j] - a[i]), m);
}
dp[i] = m;
}
cout << dp[n - 1];
return 0;
} | [
"control_flow.loop.for.condition.change"
] | 959,826 | 959,827 | u356063349 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define eb emplace_back
#define ff first
#define ss second
#define endl '\n'
#define int long long
typedef long long li;
const int N = 1e5 + 10;
int n;
int a[N];
int dp[N];
int k;
int solve(int i) {
if (i >= n - 1)
return 0;
if (dp[i] != INT_MAX)
return dp[i];
// dp[i] = abs(a[i] - a[i-1]) + solve(i+1);
for (int j = 1; j <= k; ++j) {
if (i + j > n)
break;
dp[i] = min(dp[i], abs(a[i] - a[i + j]) + solve(i + j));
}
return dp[i];
}
signed main() {
cin >> n >> k;
for (int i = 0; i < n; ++i)
cin >> a[i];
for (int i = 0; i < N; ++i)
dp[i] = INT_MAX;
// cout<<dp[0]<<" "<<dp[1]<<endl;
cout << solve(0) << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define eb emplace_back
#define ff first
#define ss second
#define endl '\n'
#define int long long
typedef long long li;
const int N = 1e5 + 10;
int n;
int a[N];
int dp[N];
int k;
int solve(int i) {
if (i >= n - 1)
return 0;
if (dp[i] != INT_MAX)
return dp[i];
// dp[i] = abs(a[i] - a[i-1]) + solve(i+1);
for (int j = 1; j <= k; ++j) {
if (i + j >= n)
break;
dp[i] = min(dp[i], abs(a[i] - a[i + j]) + solve(i + j));
}
return dp[i];
}
signed main() {
cin >> n >> k;
for (int i = 0; i < n; ++i)
cin >> a[i];
for (int i = 0; i < N; ++i)
dp[i] = INT_MAX;
// cout<<dp[0]<<" "<<dp[1]<<endl;
cout << solve(0) << endl;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 959,836 | 959,837 | u487128874 | cpp |
p03161 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define repr(i, a, b) for (int i = (a); i < (b); ++i)
#define reprev(i, n) for (int i = n - 1; i >= 0; --i)
#define reprrev(i, a, b) for (int i = b - 1; i >= (a); --i)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int main() {
cout << fixed << setprecision(10);
int N, K;
cin >> N >> K;
vector<int> h(N);
rep(i, N) cin >> h[i];
vector<int> dp(N);
dp[0] = 0;
int INF = 1e5;
repr(i, 1, N) {
int min_cost = INF;
repr(j, max(0, i - K), i) {
min_cost = min(min_cost, dp[j] + abs(h[j] - h[i]));
}
dp[i] = min_cost;
}
cout << dp[N - 1] << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define repr(i, a, b) for (int i = (a); i < (b); ++i)
#define reprev(i, n) for (int i = n - 1; i >= 0; --i)
#define reprrev(i, a, b) for (int i = b - 1; i >= (a); --i)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int main() {
cout << fixed << setprecision(10);
int N, K;
cin >> N >> K;
vector<int> h(N);
rep(i, N) cin >> h[i];
vector<int> dp(N);
dp[0] = 0;
int INF = 1e+9;
repr(i, 1, N) {
int min_cost = INF;
repr(j, max(0, i - K), i) {
min_cost = min(min_cost, dp[j] + abs(h[j] - h[i]));
}
dp[i] = min_cost;
}
cout << dp[N - 1] << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 959,844 | 959,845 | u495903598 | cpp |
p03161 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define repr(i, a, b) for (int i = a; i < (b); ++i)
#define reprev(i, n) for (int i = n - 1; i >= 0; --i)
#define reprrev(i, a, b) for (int i = b - 1; i >= (a); --i)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int main() {
cout << fixed << setprecision(10);
int N, K;
cin >> N >> K;
vector<int> h(N);
rep(i, N) cin >> h[i];
vector<int> dp(N);
dp[0] = 0;
int INF = 1e5;
repr(i, 1, N) {
int min_cost = INF;
repr(j, max(0, i - K), i) {
min_cost = min(min_cost, dp[j] + abs(h[j] - h[i]));
}
dp[i] = min_cost;
}
cout << dp[N - 1] << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define repr(i, a, b) for (int i = (a); i < (b); ++i)
#define reprev(i, n) for (int i = n - 1; i >= 0; --i)
#define reprrev(i, a, b) for (int i = b - 1; i >= (a); --i)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int main() {
cout << fixed << setprecision(10);
int N, K;
cin >> N >> K;
vector<int> h(N);
rep(i, N) cin >> h[i];
vector<int> dp(N);
dp[0] = 0;
int INF = 1e+9;
repr(i, 1, N) {
int min_cost = INF;
repr(j, max(0, i - K), i) {
min_cost = min(min_cost, dp[j] + abs(h[j] - h[i]));
}
dp[i] = min_cost;
}
cout << dp[N - 1] << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 959,846 | 959,845 | u495903598 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pairll = pair<ll, ll>;
#define ABS(x) ((x) > 0 ? (x) : -(x))
ll gcd(ll a, ll b) {
if (a == 0 || b == 0)
return 0;
if (a < b)
swap(a, b);
ll tmp = a % b;
while (tmp != 0) {
a = b;
b = tmp;
tmp = a % b;
}
return b;
}
ll factorial(ll x) {
ll f = 1;
for (ll i = 2; i < x; i++) {
f *= i;
}
return f;
}
ll npr(ll n, ll r) {
ll result = 1;
for (ll i = r + 1; i <= n; i++)
result *= i;
return result;
}
bool IsPrime(ll num) {
if (num < 2)
return false;
else if (num == 2)
return true;
else if (num % 2 == 0)
return false; // 偶数はあらかじめ除く
double sqrtNum = sqrt(num);
for (ll i = 3; i <= sqrtNum; i += 2) {
if (num % i == 0) {
// 素数ではない
return false;
}
}
// 素数である
return true;
}
ll GreaterBinarySearch(ll *array, ll key, ll max, ll min) {
if (array[max] < array[min]) {
return NULL;
} else {
ll mid = max + (min - max) / 2;
if (array[mid] < key) {
return GreaterBinarySearch(array, key, max, mid - 1);
}
if (array[mid] > key) {
return GreaterBinarySearch(array, key, mid + 1, min);
} else {
return mid;
}
}
}
int main() {
int n, k;
cin >> n >> k;
int h[n];
for (int &hi : h)
cin >> hi;
ll score[n];
for (ll &sc : score)
sc = 1LL << 60;
score[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 1; j < k; j++) {
if (i + j > n - 1)
break;
score[i + j] = min(score[i + j], score[i] + ABS(h[i + j] - h[i]));
}
}
cout << score[n - 1] << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pairll = pair<ll, ll>;
#define ABS(x) ((x) > 0 ? (x) : -(x))
ll gcd(ll a, ll b) {
if (a == 0 || b == 0)
return 0;
if (a < b)
swap(a, b);
ll tmp = a % b;
while (tmp != 0) {
a = b;
b = tmp;
tmp = a % b;
}
return b;
}
ll factorial(ll x) {
ll f = 1;
for (ll i = 2; i < x; i++) {
f *= i;
}
return f;
}
ll npr(ll n, ll r) {
ll result = 1;
for (ll i = r + 1; i <= n; i++)
result *= i;
return result;
}
bool IsPrime(ll num) {
if (num < 2)
return false;
else if (num == 2)
return true;
else if (num % 2 == 0)
return false; // 偶数はあらかじめ除く
double sqrtNum = sqrt(num);
for (ll i = 3; i <= sqrtNum; i += 2) {
if (num % i == 0) {
// 素数ではない
return false;
}
}
// 素数である
return true;
}
ll GreaterBinarySearch(ll *array, ll key, ll max, ll min) {
if (array[max] < array[min]) {
return NULL;
} else {
ll mid = max + (min - max) / 2;
if (array[mid] < key) {
return GreaterBinarySearch(array, key, max, mid - 1);
}
if (array[mid] > key) {
return GreaterBinarySearch(array, key, mid + 1, min);
} else {
return mid;
}
}
}
int main() {
int n, k;
cin >> n >> k;
int h[n];
for (int &hi : h)
cin >> hi;
ll score[n];
for (ll &sc : score)
sc = 1LL << 60;
score[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= k; j++) {
if (i + j > n - 1)
break;
score[i + j] = min(score[i + j], score[i] + ABS(h[i + j] - h[i]));
}
}
cout << score[n - 1] << endl;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 959,854 | 959,855 | u195036695 | cpp |
p03161 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ll n, k;
cin >> n >> k;
ll a[n + 1];
for (ll i = 1; i < n + 1; i++)
cin >> a[i];
vector<int> dp(n + 1, 0);
dp[1] = 0;
dp[2] = abs(a[1] - a[2]);
for (ll i = 3; i <= n; i++) {
ll b = 100001;
for (ll l = 1; l <= k; l++) {
if (i - l <= 0)
break;
b = min(dp[i - l] + abs(a[i] - a[i - l]), b);
}
dp[i] = b;
}
cout << dp[n];
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ll n, k;
cin >> n >> k;
ll a[n + 1];
for (ll i = 1; i < n + 1; i++)
cin >> a[i];
vector<int> dp(n + 1, 0);
dp[1] = 0;
dp[2] = abs(a[1] - a[2]);
for (ll i = 3; i <= n; i++) {
ll b = 10000000001;
for (ll l = 1; l <= k; l++) {
if (i - l <= 0)
break;
b = min(dp[i - l] + abs(a[i] - a[i - l]), b);
}
dp[i] = b;
}
cout << dp[n];
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 959,876 | 959,877 | u287619443 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.