oj.uz

Submission #622627

# Submission time Handle Problem Language Result Execution time Memory
622627 2022-08-04T12:43:06 Z slime Uplifting Excursion (BOI22_vault) C++14
30 / 100
 196 ms 524288 KB 
#include "bits/stdc++.h"
using namespace std;
#define int long long
const int MAXN = 3e5 + 10;
const int MOD = 1e9 + 7;
#define ll __int128
mt19937_64 rng((int)std::chrono::steady_clock::now().time_since_epoch().count());
int rnd(int x, int y) {
  int u = uniform_int_distribution<int>(x, y)(rng); return u;
}
ll read() { int x; cin >> x; return (ll)x; }
long long bm(long long b, long long p) {
  if(p==0) return 1 % MOD;
  long long r = bm(b, p >> 1);
  if(p&1) return (((r*r) % MOD) * b) % MOD;
  return (r*r) % MOD;
}
long long inv(long long b) { 
  return bm(b, MOD-2);
}
long long f[MAXN];
long long nCr(int n, int r) { 
  long long ans = f[n]; ans *= inv(f[r]); ans %= MOD;
  ans *= inv(f[n-r]); ans %= MOD; return ans;
}
long long fib[MAXN], lucas[MAXN];
void precomp() { 
  for(int i=0; i<MAXN; i++) f[i] = (i == 0 ? 1 % MOD : (f[i-1] * i) % MOD); 
  lucas[0] = 2;
  lucas[1] = 1;
  for(int i=2; i<MAXN; i++) lucas[i] = (lucas[i-2] + lucas[i-1]) % MOD;
  fib[0] = 0;
  fib[1] = 1;
  for(int i=2; i<MAXN; i++) fib[i] = (fib[i-2] + fib[i-1]) % MOD;
}
int fastlog(int x) {
  return (x == 0 ? -1 : 64 - __builtin_clzll(x) - 1);
}
void gay(int i) { cout << "Case #" << i << ": "; }
int csb(int l, int r, int k) { // count number of [l, r] such that i & 2^k > 0
  if(l > r) return 0;
  if(l == 0) {
    int s = r / (1ll << (k+1)); // number of complete cycles
    int t = r % (1ll << (k+1));
    int ans = s * (1ll << k);
    ans += (t >= (1ll << k) ? t - (1ll << k) + 1 : 0);
    return ans;
  }
  else return csb(0, r, k) - csb(0, l - 1, k);
}
int lis(vector<int> a) {
  int n = a.size();
  int bucket[n+1];
  for(int i=1; i<=n; i++) bucket[i] = 1e18;
  int ans = 1;
  for(int x: a) {
    auto it = lower_bound(bucket + 1, bucket +n +1, x);
    int d = distance(bucket, it);
    ans = max(ans, d);
    bucket[d] = min(bucket[d], x);
  }
  return ans;
}
const int maxm = 300;
vector<int> all_min_knapsacks(vector<int> v, int l, int r) {
  int freq[maxm * 2 + 1];
  for(int i=0; i<=maxm * 2; i++) freq[i] = 0;
  for(int x: v) freq[x + maxm]++;
  int dp[maxm * 2 + 1][r-l+2];
  for(int i=0; i<=maxm * 2; i++) for(int j=0; j<r-l+2; j++) dp[i][j] = 1e18;
  for(int i=l; i<=0; i++) {
    if(i % maxm == 0 && abs(i / maxm) <= freq[0]) {
      dp[0][i-l] = abs(i/maxm);
    }
  }
  for(int i=1; i<=maxm * 2; i++) { // real i: i-maxm
    if(freq[i] == 0) {
      for(int j=l; j<=r; j++) {
        dp[i][j-l] = dp[i-1][j-l];
      }
    }
    else if(i - maxm == 0) {
      for(int j=l; j<=r; j++) {
        dp[i][j-l] = dp[i-1][j-l]; // min knapsack: no extra added
      }
    }
    else if(i - maxm < 0) {
      int f = abs(i - maxm);
      deque<pair<int, int> > dq[f];
      for(int j=r; j>=l; j--) {
        dp[i][j-l] = dp[i-1][j-l];
        int u = (j-l) % abs(i - maxm);
        int v = (j-l) / abs(i - maxm);
        while(dq[u].size() && dq[u].back().first > dp[i-1][j-l] - v) {
          dq[u].pop_back();
        }
        dq[u].push_back({dp[i-1][j-l] - v, j});
        while(dq[u].size() && abs(j-dq[u].front().second) / abs(i-maxm) > freq[i]) {
          dq[u].pop_front();
        }
        dp[i][j-l] = min(dp[i][j-l], dq[u].front().first + v);
      }
    }
    else {
      int f = abs(i - maxm);
      deque<pair<int, int> > dq[f];
      for(int j=l; j<=r; j++) {
        dp[i][j-l] = dp[i-1][j-l];
        int u = (j-l) % abs(i - maxm);
        int v = (j-l) / abs(i - maxm);
        while(dq[u].size() && dq[u].back().first > dp[i-1][j-l] - v) {
          dq[u].pop_back();
        }
        dq[u].push_back({dp[i-1][j-l] - v, j});
        while(dq[u].size() && abs(j-dq[u].front().second) / abs(i-maxm) > freq[i]) {
          dq[u].pop_front();
        }
        dp[i][j-l] = min(dp[i][j-l], dq[u].front().first + v);
      }
    }
    /*
    for(int j=l; j<=r; j++) {
      dp[i][j-l] = dp[i-1][j-l];
      for(int k=1; k<=freq[i]; k++) {
        int res = j - k * (i - maxm);
        if(l <= res && res <= r) dp[i][j-l] = min(dp[i][j-l], dp[i-1][res-l] + k);
      }
    }
    */
  }
  vector<int> vt;
  for(int i=l; i<=r; i++) {
    if(dp[maxm * 2][i-l] > 1e16) vt.push_back(-1);
    else vt.push_back(dp[maxm * 2][i-l]);
  }
  return vt;
}
vector<int> all_max_knapsacks(vector<int> v, int l, int r) {
  int freq[maxm * 2 + 1];
  for(int i=0; i<=maxm * 2; i++) freq[i] = 0;
  for(int x: v) freq[x + maxm]++;
  int dp[maxm * 2 + 1][r-l+2];
  for(int i=0; i<=maxm * 2; i++) for(int j=0; j<r-l+2; j++) dp[i][j] = -1e18;
  for(int i=l; i<=0; i++) {
    if(i % maxm == 0 && abs(i / maxm) <= freq[0]) {
      dp[0][i-l] = abs(i/maxm);
    }
  }
  for(int i=1; i<=maxm * 2; i++) { // real i: i-maxm
    if(freq[i] == 0) {
      for(int j=l; j<=r; j++) {
        dp[i][j-l] = dp[i-1][j-l];
      }
    }
    else if(i - maxm == 0) {
      for(int j=l; j<=r; j++) {
        dp[i][j-l] = dp[i-1][j-l] + freq[i]; // max knapsack: add all
      }
    }
    else if(i - maxm < 0) {
      int f = abs(i - maxm);
      deque<pair<int, int> > dq[f];
      for(int j=r; j>=l; j--) {
        dp[i][j-l] = dp[i-1][j-l];
        int u = (j-l) % abs(i - maxm);
        int v = (j-l) / abs(i - maxm);
        while(dq[u].size() && dq[u].back().first < dp[i-1][j-l] - v) {
          dq[u].pop_back();
        }
        dq[u].push_back({dp[i-1][j-l] - v, j});
        while(dq[u].size() && abs(j-dq[u].front().second) / abs(i-maxm) > freq[i]) {
          dq[u].pop_front();
        }
        dp[i][j-l] = max(dp[i][j-l], dq[u].front().first + v);
      }
    }
    else {
      int f = abs(i - maxm);
      deque<pair<int, int> > dq[f];
      for(int j=l; j<=r; j++) {
        dp[i][j-l] = dp[i-1][j-l];
        int u = (j-l) % abs(i - maxm);
        int v = (j-l) / abs(i - maxm);
        while(dq[u].size() && dq[u].back().first < dp[i-1][j-l] - v) {
          dq[u].pop_back();
        }
        dq[u].push_back({dp[i-1][j-l] - v, j});
        while(dq[u].size() && abs(j-dq[u].front().second) / abs(i-maxm) > freq[i]) {
          dq[u].pop_front();
        }
        dp[i][j-l] = max(dp[i][j-l], dq[u].front().first + v);
      }
    }
    /*
    for(int j=l; j<=r; j++) {
      dp[i][j-l] = dp[i-1][j-l];
      for(int k=1; k<=freq[i]; k++) {
        int res = j - k * (i - maxm);
        if(l <= res && res <= r) dp[i][j-l] = min(dp[i][j-l], dp[i-1][res-l] + k);
      }
    }
    */
  }
  vector<int> vt;
  for(int i=l; i<=r; i++) {
    if(dp[maxm * 2][i-l] < -1e16) vt.push_back(-1);
    else vt.push_back(dp[maxm * 2][i-l]);
  }
  return vt;
}
void solve(int tc) {
  int m, l; cin >> m >> l;
  unordered_map<int, int> a;
  for(int i=-m; i<=m; i++) cin >> a[i];
  if(l < 0) {
    for(int i=-m; i<0; i++) swap(a[i], a[-i]);
    l = -l;
  }
  int cnt = a[0], sum = 0;
  for(int i=1; i<=m; i++) {
    int owo = (a[i] - a[-i]) * i;
    cnt += a[i] + a[-i];
    sum += owo;
  }
  if(sum == l) {
    cout << cnt << "\n"; return;
  }
  unordered_map<int, int> chosen;
  for(int i=-m; i<=m; i++) chosen[i] = a[i];
  if(sum < l) {
    for(int i=-m; i<0; i++) {
      int rem = (l - sum) / (-i);
      rem = min(rem, a[i]);
      if(sum - rem * i == l) {
        chosen[i] -= rem; 
        sum -= rem * i;
        break;
      }
      if(rem == a[i]) {
        chosen[i] = 0;
        sum -= rem * i;
      }
      else {
        rem++;
        chosen[i] -= rem;
        sum -= rem * i;
        break;
      }
    }
    if(sum < l) {
      cout << "impossible\n"; return;
    }
  }
  else {
    for(int i=m; i>0; i--) {
      int rem = (sum - l) / i;
      rem = min(rem, a[i]);
      chosen[i] -= rem;
      sum -= rem * i;
    }
  }
  if(sum == l) {
    int sm = 0;
    for(int i=-m; i<=m; i++) sm += chosen[i];
    cout << sm << "\n";
    return;
  }
  vector<int> in, out;
  for(int i=-m; i<=m; i++) {
    for(int j=0; j<min(m, chosen[i]); j++) in.push_back(i);
    for(int j=0; j<min(m, a[i] - chosen[i]); j++) out.push_back(i);
  }
  if(in.empty() || out.empty()) {
    cout << "impossible\n"; return;
  }
  int A = sum - l;
  vector<int> resin = all_min_knapsacks(in, -m*m, m*m);
  vector<int> resout = all_max_knapsacks(out, -m*m, m*m);
  int sm = 0;
  for(int i=-m; i<=m; i++) sm += chosen[i];
  int ans = -1;
  int id;
  for(int x=0; x<resout.size(); x++) {
    if(resout[x] != -1 && A + x < resin.size() && resin[A + x] != -1) {
      if(sm - resin[A + x] + resout[x] > ans) {
        ans = sm - resin[A + x] + resout[x];
        id = x;
      }
    }
  }
  cout << (ans == -1 ? "impossible" : to_string(ans)) << "\n";
} 
int32_t main() {
  precomp();
  ios::sync_with_stdio(0); cin.tie(0);
  int t = 1; //cin >> t;
  for(int i=1; i<=t; i++) solve(i);
}
// I don't know geometry.
// Teaming is unfair.

/*
5 16
0 0 0 0 0 0 0 0 3 2 1
*/

Compilation message

vault.cpp: In function 'void solve(long long int)':
vault.cpp:283:17: warning: comparison of integer expressions of different signedness: 'long long int' and 'std::vector<long long int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  283 |   for(int x=0; x<resout.size(); x++) {
      |                ~^~~~~~~~~~~~~~
vault.cpp:284:33: warning: comparison of integer expressions of different signedness: 'long long int' and 'std::vector<long long int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  284 |     if(resout[x] != -1 && A + x < resin.size() && resin[A + x] != -1) {
      |                           ~~~~~~^~~~~~~~~~~~~~
vault.cpp:282:7: warning: variable 'id' set but not used [-Wunused-but-set-variable]
  282 |   int id;
      |       ^~

Subtask #1
0 / 5.0

# Verdict Execution time Memory Grader output
1 Correct 7 ms 7380 KB Output is correct
2 Correct 8 ms 7380 KB Output is correct
3 Correct 7 ms 7368 KB Output is correct
4 Correct 8 ms 7348 KB Output is correct
5 Correct 8 ms 7380 KB Output is correct
6 Incorrect 43 ms 31040 KB Output isn't correct
7 Halted 0 ms 0 KB -

Subtask #2
0 / 15.0

# Verdict Execution time Memory Grader output
1 Correct 7 ms 7380 KB Output is correct
2 Correct 8 ms 7380 KB Output is correct
3 Correct 7 ms 7368 KB Output is correct
4 Correct 8 ms 7348 KB Output is correct
5 Correct 8 ms 7380 KB Output is correct
6 Incorrect 43 ms 31040 KB Output isn't correct
7 Halted 0 ms 0 KB -

Subtask #3-1
10.0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 8 ms 7252 KB Output is correct
2 Correct 8 ms 7376 KB Output is correct
3 Correct 15 ms 15864 KB Output is correct
4 Correct 7 ms 7324 KB Output is correct
5 Correct 8 ms 7312 KB Output is correct
6 Correct 9 ms 7380 KB Output is correct
7 Correct 14 ms 15808 KB Output is correct
8 Correct 14 ms 15844 KB Output is correct
9 Correct 8 ms 7380 KB Output is correct
10 Correct 9 ms 7380 KB Output is correct

Subtask #3-2
0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 8 ms 7252 KB Output is correct
2 Correct 8 ms 7376 KB Output is correct
3 Correct 15 ms 15864 KB Output is correct
4 Correct 7 ms 7324 KB Output is correct
5 Correct 8 ms 7312 KB Output is correct
6 Correct 9 ms 7380 KB Output is correct
7 Correct 14 ms 15808 KB Output is correct
8 Correct 14 ms 15844 KB Output is correct
9 Correct 8 ms 7380 KB Output is correct
10 Correct 9 ms 7380 KB Output is correct
11 Correct 9 ms 7380 KB Output is correct
12 Correct 8 ms 7420 KB Output is correct
13 Correct 8 ms 7252 KB Output is correct
14 Correct 7 ms 7252 KB Output is correct
15 Correct 8 ms 7364 KB Output is correct
16 Correct 15 ms 15816 KB Output is correct
17 Correct 8 ms 7444 KB Output is correct
18 Correct 7 ms 7380 KB Output is correct
19 Correct 8 ms 7332 KB Output is correct
20 Correct 14 ms 15816 KB Output is correct
21 Correct 14 ms 15848 KB Output is correct
22 Correct 7 ms 7308 KB Output is correct
23 Correct 8 ms 7380 KB Output is correct
24 Correct 7 ms 7332 KB Output is correct
25 Correct 15 ms 15828 KB Output is correct
26 Incorrect 17 ms 15924 KB Output isn't correct
27 Halted 0 ms 0 KB -

Subtask #4-1
10.0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 8 ms 7252 KB Output is correct
2 Correct 8 ms 7376 KB Output is correct
3 Correct 15 ms 15864 KB Output is correct
4 Correct 7 ms 7324 KB Output is correct
5 Correct 8 ms 7312 KB Output is correct
6 Correct 9 ms 7380 KB Output is correct
7 Correct 14 ms 15808 KB Output is correct
8 Correct 14 ms 15844 KB Output is correct
9 Correct 8 ms 7380 KB Output is correct
10 Correct 9 ms 7380 KB Output is correct
11 Correct 7 ms 7372 KB Output is correct
12 Correct 9 ms 7292 KB Output is correct
13 Correct 16 ms 15828 KB Output is correct
14 Correct 8 ms 7380 KB Output is correct
15 Correct 9 ms 7288 KB Output is correct
16 Correct 8 ms 7328 KB Output is correct
17 Correct 15 ms 15828 KB Output is correct
18 Correct 14 ms 15828 KB Output is correct
19 Correct 8 ms 7372 KB Output is correct
20 Correct 8 ms 7252 KB Output is correct
21 Correct 28 ms 31028 KB Output is correct
22 Correct 29 ms 31048 KB Output is correct
23 Correct 7 ms 7380 KB Output is correct
24 Correct 31 ms 31048 KB Output is correct
25 Correct 8 ms 7368 KB Output is correct
26 Correct 8 ms 7252 KB Output is correct
27 Correct 8 ms 7300 KB Output is correct
28 Correct 9 ms 7380 KB Output is correct

Subtask #4-2
0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 7 ms 7380 KB Output is correct
2 Correct 8 ms 7380 KB Output is correct
3 Correct 7 ms 7368 KB Output is correct
4 Correct 8 ms 7348 KB Output is correct
5 Correct 8 ms 7380 KB Output is correct
6 Incorrect 43 ms 31040 KB Output isn't correct
7 Halted 0 ms 0 KB -

Subtask #5-1
10.0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 8 ms 7252 KB Output is correct
2 Correct 8 ms 7376 KB Output is correct
3 Correct 15 ms 15864 KB Output is correct
4 Correct 7 ms 7324 KB Output is correct
5 Correct 8 ms 7312 KB Output is correct
6 Correct 9 ms 7380 KB Output is correct
7 Correct 14 ms 15808 KB Output is correct
8 Correct 14 ms 15844 KB Output is correct
9 Correct 8 ms 7380 KB Output is correct
10 Correct 9 ms 7380 KB Output is correct
11 Correct 7 ms 7372 KB Output is correct
12 Correct 9 ms 7292 KB Output is correct
13 Correct 16 ms 15828 KB Output is correct
14 Correct 8 ms 7380 KB Output is correct
15 Correct 9 ms 7288 KB Output is correct
16 Correct 8 ms 7328 KB Output is correct
17 Correct 15 ms 15828 KB Output is correct
18 Correct 14 ms 15828 KB Output is correct
19 Correct 8 ms 7372 KB Output is correct
20 Correct 8 ms 7252 KB Output is correct
21 Correct 28 ms 31028 KB Output is correct
22 Correct 29 ms 31048 KB Output is correct
23 Correct 7 ms 7380 KB Output is correct
24 Correct 31 ms 31048 KB Output is correct
25 Correct 8 ms 7368 KB Output is correct
26 Correct 8 ms 7252 KB Output is correct
27 Correct 8 ms 7300 KB Output is correct
28 Correct 9 ms 7380 KB Output is correct
29 Correct 7 ms 7368 KB Output is correct
30 Correct 8 ms 7380 KB Output is correct
31 Correct 15 ms 15804 KB Output is correct
32 Correct 8 ms 7332 KB Output is correct
33 Correct 8 ms 7372 KB Output is correct
34 Correct 8 ms 7364 KB Output is correct
35 Correct 14 ms 15812 KB Output is correct
36 Correct 14 ms 15828 KB Output is correct
37 Correct 8 ms 7252 KB Output is correct
38 Correct 8 ms 7336 KB Output is correct
39 Correct 34 ms 31036 KB Output is correct
40 Correct 31 ms 30980 KB Output is correct
41 Correct 8 ms 7372 KB Output is correct
42 Correct 31 ms 31052 KB Output is correct
43 Correct 8 ms 7268 KB Output is correct
44 Correct 9 ms 7372 KB Output is correct
45 Correct 9 ms 7372 KB Output is correct
46 Correct 8 ms 7364 KB Output is correct
47 Correct 91 ms 102196 KB Output is correct
48 Correct 97 ms 102064 KB Output is correct
49 Correct 8 ms 7380 KB Output is correct
50 Correct 113 ms 102136 KB Output is correct
51 Correct 7 ms 7380 KB Output is correct
52 Correct 8 ms 7380 KB Output is correct
53 Correct 8 ms 7380 KB Output is correct
54 Correct 8 ms 7368 KB Output is correct

Subtask #5-2
0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 7 ms 7380 KB Output is correct
2 Correct 8 ms 7380 KB Output is correct
3 Correct 7 ms 7368 KB Output is correct
4 Correct 8 ms 7348 KB Output is correct
5 Correct 8 ms 7380 KB Output is correct
6 Incorrect 43 ms 31040 KB Output isn't correct
7 Halted 0 ms 0 KB -

Subtask #6-1
0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 8 ms 7252 KB Output is correct
2 Correct 8 ms 7376 KB Output is correct
3 Correct 15 ms 15864 KB Output is correct
4 Correct 7 ms 7324 KB Output is correct
5 Correct 8 ms 7312 KB Output is correct
6 Correct 9 ms 7380 KB Output is correct
7 Correct 14 ms 15808 KB Output is correct
8 Correct 14 ms 15844 KB Output is correct
9 Correct 8 ms 7380 KB Output is correct
10 Correct 9 ms 7380 KB Output is correct
11 Correct 7 ms 7372 KB Output is correct
12 Correct 9 ms 7292 KB Output is correct
13 Correct 16 ms 15828 KB Output is correct
14 Correct 8 ms 7380 KB Output is correct
15 Correct 9 ms 7288 KB Output is correct
16 Correct 8 ms 7328 KB Output is correct
17 Correct 15 ms 15828 KB Output is correct
18 Correct 14 ms 15828 KB Output is correct
19 Correct 8 ms 7372 KB Output is correct
20 Correct 8 ms 7252 KB Output is correct
21 Correct 28 ms 31028 KB Output is correct
22 Correct 29 ms 31048 KB Output is correct
23 Correct 7 ms 7380 KB Output is correct
24 Correct 31 ms 31048 KB Output is correct
25 Correct 8 ms 7368 KB Output is correct
26 Correct 8 ms 7252 KB Output is correct
27 Correct 8 ms 7300 KB Output is correct
28 Correct 9 ms 7380 KB Output is correct
29 Correct 7 ms 7368 KB Output is correct
30 Correct 8 ms 7380 KB Output is correct
31 Correct 15 ms 15804 KB Output is correct
32 Correct 8 ms 7332 KB Output is correct
33 Correct 8 ms 7372 KB Output is correct
34 Correct 8 ms 7364 KB Output is correct
35 Correct 14 ms 15812 KB Output is correct
36 Correct 14 ms 15828 KB Output is correct
37 Correct 8 ms 7252 KB Output is correct
38 Correct 8 ms 7336 KB Output is correct
39 Correct 34 ms 31036 KB Output is correct
40 Correct 31 ms 30980 KB Output is correct
41 Correct 8 ms 7372 KB Output is correct
42 Correct 31 ms 31052 KB Output is correct
43 Correct 8 ms 7268 KB Output is correct
44 Correct 9 ms 7372 KB Output is correct
45 Correct 9 ms 7372 KB Output is correct
46 Correct 8 ms 7364 KB Output is correct
47 Correct 91 ms 102196 KB Output is correct
48 Correct 97 ms 102064 KB Output is correct
49 Correct 8 ms 7380 KB Output is correct
50 Correct 113 ms 102136 KB Output is correct
51 Correct 7 ms 7380 KB Output is correct
52 Correct 8 ms 7380 KB Output is correct
53 Correct 8 ms 7380 KB Output is correct
54 Correct 8 ms 7368 KB Output is correct
55 Correct 8 ms 7252 KB Output is correct
56 Correct 8 ms 7336 KB Output is correct
57 Correct 15 ms 15820 KB Output is correct
58 Correct 10 ms 7372 KB Output is correct
59 Correct 9 ms 7288 KB Output is correct
60 Correct 9 ms 7380 KB Output is correct
61 Correct 15 ms 15852 KB Output is correct
62 Correct 14 ms 15908 KB Output is correct
63 Correct 8 ms 7252 KB Output is correct
64 Correct 8 ms 7380 KB Output is correct
65 Correct 28 ms 31032 KB Output is correct
66 Correct 29 ms 31020 KB Output is correct
67 Correct 8 ms 7252 KB Output is correct
68 Correct 32 ms 30980 KB Output is correct
69 Correct 8 ms 7380 KB Output is correct
70 Correct 7 ms 7380 KB Output is correct
71 Correct 7 ms 7372 KB Output is correct
72 Correct 8 ms 7252 KB Output is correct
73 Correct 89 ms 102112 KB Output is correct
74 Correct 106 ms 102112 KB Output is correct
75 Correct 8 ms 7372 KB Output is correct
76 Correct 114 ms 102044 KB Output is correct
77 Correct 8 ms 7380 KB Output is correct
78 Correct 8 ms 7380 KB Output is correct
79 Correct 8 ms 7380 KB Output is correct
80 Correct 7 ms 7372 KB Output is correct
81 Correct 9 ms 7380 KB Output is correct
82 Runtime error 196 ms 524288 KB Execution killed with signal 9
83 Halted 0 ms 0 KB -

Subtask #6-2
0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 7 ms 7380 KB Output is correct
2 Correct 8 ms 7380 KB Output is correct
3 Correct 7 ms 7368 KB Output is correct
4 Correct 8 ms 7348 KB Output is correct
5 Correct 8 ms 7380 KB Output is correct
6 Incorrect 43 ms 31040 KB Output isn't correct
7 Halted 0 ms 0 KB -