Submission details
Task:Wario Kart II
Sender:aalto25c_004
Submission time:2025-09-17 16:58:11 +0300
Language:C++ (C++20)
Status:READY
Result:ACCEPTED
Test results
testverdicttime
#1ACCEPTED0.00 sdetails
#2ACCEPTED0.00 sdetails
#3ACCEPTED0.00 sdetails
#4ACCEPTED0.00 sdetails
#5ACCEPTED0.00 sdetails
#6ACCEPTED0.00 sdetails
#7ACCEPTED0.00 sdetails
#8ACCEPTED0.00 sdetails
#9ACCEPTED0.00 sdetails
#10ACCEPTED0.00 sdetails
#11ACCEPTED0.00 sdetails
#12ACCEPTED0.00 sdetails
#13ACCEPTED0.00 sdetails
#14ACCEPTED0.00 sdetails
#15ACCEPTED0.00 sdetails
#16ACCEPTED0.00 sdetails
#17ACCEPTED0.00 sdetails
#18ACCEPTED0.01 sdetails
#19ACCEPTED0.00 sdetails
#20ACCEPTED0.00 sdetails
#21ACCEPTED0.00 sdetails
#22ACCEPTED0.00 sdetails
#23ACCEPTED0.00 sdetails
#24ACCEPTED0.00 sdetails
#25ACCEPTED0.00 sdetails
#26ACCEPTED0.00 sdetails
#27ACCEPTED0.00 sdetails
#28ACCEPTED0.00 sdetails
#29ACCEPTED0.00 sdetails
#30ACCEPTED0.00 sdetails
#31ACCEPTED0.00 sdetails
#32ACCEPTED0.00 sdetails
#33ACCEPTED0.00 sdetails
#34ACCEPTED0.01 sdetails
#35ACCEPTED0.00 sdetails
#36ACCEPTED0.00 sdetails
#37ACCEPTED0.00 sdetails
#38ACCEPTED0.00 sdetails
#39ACCEPTED0.00 sdetails
#40ACCEPTED0.00 sdetails
#41ACCEPTED0.00 sdetails
#42ACCEPTED0.00 sdetails
#43ACCEPTED0.00 sdetails
#44ACCEPTED0.00 sdetails
#45ACCEPTED0.00 sdetails
#46ACCEPTED0.00 sdetails
#47ACCEPTED0.00 sdetails
#48ACCEPTED0.00 sdetails
#49ACCEPTED0.01 sdetails
#50ACCEPTED0.05 sdetails
#51ACCEPTED0.04 sdetails
#52ACCEPTED0.05 sdetails
#53ACCEPTED0.05 sdetails
#54ACCEPTED0.05 sdetails
#55ACCEPTED0.05 sdetails
#56ACCEPTED0.05 sdetails
#57ACCEPTED0.04 sdetails
#58ACCEPTED0.05 sdetails
#59ACCEPTED0.04 sdetails

Code

#include <bits/stdc++.h>
using namespace std;
// clang-format off
template<typename a, typename b> ostream& operator<<(ostream &os, const pair<a, b> &p) { return os << '(' << p.first << ", " << p.second << ')'; }
template<typename t_container, typename t = typename enable_if<!is_same<t_container, string>::value, typename t_container::value_type>::type> ostream& operator<<(ostream &os, const t_container &v) { os << '{'; string sep; for (const t &x : v) os << sep << x, sep = ", "; return os << '}'; }
void dbg_out() { cerr << endl; }
template<typename head, typename... tail> void dbg_out(head h, tail... t) { cerr << ' ' << h; dbg_out(t...); }
template <typename t> istream &operator>>(istream &is, vector<t> &v) { t value; is >> value; v.push_back(value); return is; }
#define preamble ios::sync_with_stdio(0); cin.tie(0); dbg("init");
// clang-format on
#ifdef do_dbg
#define dbg(...) cerr << "(" << #__va_args__ << "):", dbg_out(__va_args__)
#else
#define dbg(...)
#endif
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
template <typename t> using v = vector<t>;
template <typename t> using us = unordered_set<t>;
template <typename k, typename v> using um = unordered_map<k, v>;
constexpr int mod = 1e9 + 7;
const int inf = 1e9;
const ld eps = 1e-9;
#define loop(n) for (int i = 0; i < n; i++)
#define loopz(n) for (int z = 0; z < n; z++)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define sq(x) ((x) * (x))

int n, k;
v<int> a;
v<bool> ready;
v<ld> memo;

// returns:
// minimum time required to finish the track in seconds
// parameter:
// position on track (x100m)
ld dp(int pos) {
  if (pos >= n)
    return 0;
  if (ready[pos])
    return memo[pos];
  ld timeSpent1, timeSpent2;
  // we can either:
  // 1. not take the boost and move on to the next possible one
  {
    int newPos = pos + 1;
    timeSpent1 =
        1; // if we move 100m/s it takes a second to get to the next boost
    timeSpent1 += dp(newPos);
  }
  // 2. take the boost
  {
    int newSpeed = a[pos];

    // calculate distance and time to next decision
    int newPos =
        pos + newSpeed; // for example if it's 2x we go 200m with the boost
    // but wait:
    int distanceLeft = n - pos;
    if (newSpeed >= distanceLeft) {
      return (ld)distanceLeft / newSpeed;
    }
    // The player cannot pick up other boosts while one is in effect. After the
    // boost ends, a player also cannot use the next k boost pads they pass.
    timeSpent2 = 1;
    // we then need to go k seconds without a boost at 100m/s
    newPos += k;
    timeSpent2 += k;
    // since k is an integer we are already at a boost!
    timeSpent2 += dp(newPos);
  }
  auto res = min(timeSpent1, timeSpent2);
  memo[pos] = res;
  ready[pos] = true;
  return res;
}

int main() {
  cin >> n >> k;
  loop(n) cin >> a;
  ready.resize(n);
  memo.resize(n);
  cout << dp(0) << "\n";
}

Test details

Test 1

Verdict: ACCEPTED

input
1 5

correct output
0.33333333333333333334

user output
0.333333

Test 2

Verdict: ACCEPTED

input
2 5
3 4 

correct output
0.66666666666666666668

user output
0.666667

Test 3

Verdict: ACCEPTED

input
2 5
2 2 

correct output
1.00000000000000000000

user output
1

Test 4

Verdict: ACCEPTED

input
3 5
2 2 2 

correct output
2.00000000000000000000

user output
2

Test 5

Verdict: ACCEPTED

input
3 5
3 4 3 

correct output
1.00000000000000000000

user output
1

Test 6

Verdict: ACCEPTED

input
3 5
2 2 2 

correct output
2.00000000000000000000

user output
2

Test 7

Verdict: ACCEPTED

input
4 5
3 4 3 4 

correct output
1.75000000000000000000

user output
1.75

Test 8

Verdict: ACCEPTED

input
4 5
2 2 2 4 

correct output
3.00000000000000000000

user output
3

Test 9

Verdict: ACCEPTED

input
4 3
2 2 2 2 

correct output
3.00000000000000000000

user output
3

Test 10

Verdict: ACCEPTED

input
5 5
3 4 3 4 3 

correct output
2.00000000000000000000

user output
2

Test 11

Verdict: ACCEPTED

input
5 5
2 2 2 4 2 

correct output
3.50000000000000000000

user output
3.5

Test 12

Verdict: ACCEPTED

input
5 5
2 2 2 2 2 

correct output
4.00000000000000000000

user output
4

Test 13

Verdict: ACCEPTED

input
5 5
2 2 3 3 4 

correct output
3.00000000000000000000

user output
3

Test 14

Verdict: ACCEPTED

input
5 1
4 4 4 3 4 

correct output
2.00000000000000000000

user output
2

Test 15

Verdict: ACCEPTED

input
5 4
2 3 5 5 3 

correct output
2.59999999999999999991

user output
2.6

Test 16

Verdict: ACCEPTED

input
5 1
3 2 2 2 2 

correct output
2.50000000000000000000

user output
2.5

Test 17

Verdict: ACCEPTED

input
5 1
3 5 4 3 5 

correct output
1.79999999999999999996

user output
1.8

Test 18

Verdict: ACCEPTED

input
5 1
5 3 4 5 2 

correct output
1.00000000000000000000

user output
1

Test 19

Verdict: ACCEPTED

input
5 2
3 2 2 2 2 

correct output
3.00000000000000000000

user output
3

Test 20

Verdict: ACCEPTED

input
10 5
3 4 3 4 3 3 3 3 3 2 

correct output
6.66666666666666666652

user output
6.66667

Test 21

Verdict: ACCEPTED

input
10 5
2 2 2 4 2 2 2 3 2 3 

correct output
7.00000000000000000000

user output
7

Test 22

Verdict: ACCEPTED

input
10 5
2 2 2 2 2 2 2 2 2 2 

correct output
8.00000000000000000000

user output
8

Test 23

Verdict: ACCEPTED

input
10 5
2 2 3 3 4 3 4 2 2 2 

correct output
7.00000000000000000000

user output
7

Test 24

Verdict: ACCEPTED

input
10 1
4 4 4 3 4 3 2 2 4 2 

correct output
4.50000000000000000000

user output
4.5

Test 25

Verdict: ACCEPTED

input
10 4
2 3 5 5 3 2 4 3 5 3 

correct output
6.00000000000000000000

user output
6

Test 26

Verdict: ACCEPTED

input
10 1
3 2 2 2 2 3 3 2 3 3 

correct output
5.33333333333333333348

user output
5.33333

Test 27

Verdict: ACCEPTED

input
10 1
3 5 4 3 5 3 4 3 4 2 

correct output
4.00000000000000000000

user output
4

Test 28

Verdict: ACCEPTED

input
10 1
5 3 4 5 2 3 2 4 3 5 

correct output
3.75000000000000000000

user output
3.75

Test 29

Verdict: ACCEPTED

input
10 2
3 2 2 2 2 2 2 4 3 2 

correct output
5.75000000000000000000

user output
5.75

Test 30

Verdict: ACCEPTED

input
100 72
51 37 52 34 51 26 38 40 24 27 ...

correct output
42.00000000000000000000

user output
51.8596

Test 31

Verdict: ACCEPTED

input
100 72
94 2 14 31 100 16 25 11 41 20 ...

correct output
4.96000000000000000003

user output
4.96

Test 32

Verdict: ACCEPTED

input
100 2
19 12 20 10 11 9 8 8 4 5 15 13...

correct output
18.70588235294117647120

user output
18.7059

Test 33

Verdict: ACCEPTED

input
100 71
8 4 2 6 6 9 5 9 2 3 2 3 3 2 2 ...

correct output
85.00000000000000000000

user output
85

Test 34

Verdict: ACCEPTED

input
100 55
17 89 79 66 56 64 55 21 14 89 ...

correct output
12.00000000000000000000

user output
22

Test 35

Verdict: ACCEPTED

input
100 87
6 3 4 7 7 4 2 5 4 6 4 5 4 3 7 ...

correct output
90.00000000000000000000

user output
91

Test 36

Verdict: ACCEPTED

input
100 33
21 79 8 5 36 12 94 57 11 51 59...

correct output
7.00000000000000000000

user output
7

Test 37

Verdict: ACCEPTED

input
100 78
9 12 24 18 12 24 9 14 8 13 3 3...

correct output
77.00000000000000000000

user output
79.7222

Test 38

Verdict: ACCEPTED

input
100 97
2 3 2 3 3 2 2 2 3 2 3 2 2 3 3 ...

correct output
98.00000000000000000000

user output
98.3333

Test 39

Verdict: ACCEPTED

input
100 50
20 20 2 6 13 7 2 10 34 17 7 11...

correct output
52.96666666666666666713

user output
52.9667

Test 40

Verdict: ACCEPTED

input
200 72
51 37 52 34 51 26 38 40 24 27 ...

correct output
89.00000000000000000000

user output
89

Test 41

Verdict: ACCEPTED

input
200 72
94 2 14 31 100 16 25 11 41 20 ...

correct output
73.91891891891891892136

user output
73.9189

Test 42

Verdict: ACCEPTED

input
200 2
19 12 20 10 11 9 8 8 4 5 15 13...

correct output
36.90000000000000000139

user output
36.9

Test 43

Verdict: ACCEPTED

input
200 71
8 4 2 6 6 9 5 9 2 3 2 3 3 2 2 ...

correct output
177.00000000000000000000

user output
177.889

Test 44

Verdict: ACCEPTED

input
200 55
17 89 79 66 56 64 55 21 14 89 ...

correct output
58.62790697674418604821

user output
58.6279

Test 45

Verdict: ACCEPTED

input
200 87
6 3 4 7 7 4 2 5 4 6 4 5 4 3 7 ...

correct output
184.00000000000000000000

user output
185.429

Test 46

Verdict: ACCEPTED

input
200 33
21 79 8 5 36 12 94 57 11 51 59...

correct output
39.97647058823529411797

user output
39.9765

Test 47

Verdict: ACCEPTED

input
1000 78
9 12 24 18 12 24 9 14 8 13 3 3...

correct output
778.00000000000000000000

user output
780

Test 48

Verdict: ACCEPTED

input
1000 97
2 3 2 3 3 2 2 2 3 2 3 2 2 3 3 ...

correct output
980.00000000000000000000

user output
981

Test 49

Verdict: ACCEPTED

input
10000 50
20 20 2 6 13 7 2 10 34 17 7 11...

correct output
6049.00000000000000000000

user output
6049.97

Test 50

Verdict: ACCEPTED

input
100000 59
39252 46336 33082 47087 29905 ...

correct output
64.97006295772838237179

user output
64.9701

Test 51

Verdict: ACCEPTED

input
100000 100
30041 38891 6 5345 12609 41664...

correct output
203.77740406665647454609

user output
203.777

Test 52

Verdict: ACCEPTED

input
100000 18
1132 40617 23967 41323 18982 2...

correct output
40.94677609727978918885

user output
40.9468

Test 53

Verdict: ACCEPTED

input
100000 7
39007 46266 16025 6684 28138 3...

correct output
14.93255621844882973827

user output
14.9326

Test 54

Verdict: ACCEPTED

input
100000 90
52921 16702 94063 82743 69126 ...

correct output
91.66979787325027796002

user output
91.6698

Test 55

Verdict: ACCEPTED

input
100000 5
19332 18457 4591 8077 20395 21...

correct output
35.88927530302255408320

user output
35.8893

Test 56

Verdict: ACCEPTED

input
100000 95
29643 18699 73326 5739 3724 33...

correct output
96.91999685748703713406

user output
96.92

Test 57

Verdict: ACCEPTED

input
100000 22
5953 2436 3347 7466 5522 3478 ...

correct output
330.93907248742010063225

user output
330.939

Test 58

Verdict: ACCEPTED

input
100000 1
84598 20915 75920 32975 46369 ...

correct output
2.81955087271179225200

user output
2.81955

Test 59

Verdict: ACCEPTED

input
100000 36
522 520 516 9 140 330 149 15 2...

correct output
3870.97771317829457360382

user output
3870.98