답안 #1112990

# 제출 시각 아이디 문제 언어 결과 실행 시간 메모리
1112990 2024-11-15T11:01:50 Z SalihSahin 커다란 상품 (IOI17_prize) C++14
20 / 100
214 ms 14272 KB
#include <bits/stdc++.h>
#define pb push_back
#include "prize.h"

using namespace std;
/*
static const int max_q = 10000;
static int n;
static int query_count = 0;
static vector<int> g;
static vector<vector<int> > rank_count;

vector<int> ask(int i) {
   query_count++;
   if(query_count > max_q) {
      cerr << "Query limit exceeded" << endl;
      //cout<<query_count<<" babag "<<endl;
      exit(0);
   }

   if(i < 0 || i >= n) {
      cerr << "Bad index: " << i << endl;
      exit(0);
   }

   vector<int> res(2);
   res[0] = rank_count[g[i] - 1][i + 1];
   res[1] = rank_count[g[i] - 1][n] - res[0];
   return res;
}
*/

const int MAXN = 2e5 + 5;
vector<vector<int> > check(MAXN, vector<int>(2, -1));
vector<int> small(MAXN);

void f(int n, int smallcnt, int l, int r, int cnt){
   if(l == r){
      small[l] = 1;
      return;
   }
   int mid = (l + r)/2;
   int m = -1;

   int k = rand() % 23;
   if(k >= 6){
      vector<int> delts;
      for(int i = l; i <= r; i++){
         delts.pb(i);
      } 
      random_shuffle(delts.begin(), delts.end());
      for(int i = 0; i < delts.size(); i++){
         if(check[delts[i]][0] == -1) check[delts[i]] = ask(delts[i]);
         if(check[delts[i]][0] + check[delts[i]][1] == smallcnt){
            m = delts[i];
            break;
         }
         else{
            small[delts[i]] = 1;
         }
      }
   }
   else{
      for(int delt = 0; delt <= (r - l + 1)/2 + 1; delt++){
         if(mid + delt <= r){
            if(check[mid + delt][0] == -1) check[mid + delt] = ask(mid + delt);
            if(check[mid + delt][0] + check[mid + delt][1] == smallcnt){
               m = mid + delt;
               break;
            }
            else{
               small[mid + delt] = 1;
            }
         }

         if(mid - delt >= l){
            if(check[mid - delt][0] == -1) check[mid - delt] = ask(mid - delt);
            if(check[mid - delt][0] + check[mid - delt][1] == smallcnt){
               m = mid - delt;
               break;
            }
            else{
               small[mid - delt] = 1;
            }
         }
      }
   }

   if(m == -1) return; // aralıktaki herkes small ve tagledik
   if(l > 0 && check[l-1][0] == -1) check[l-1] = ask(l-1);
   if(r < n-1 && check[r+1][0] == -1) check[r+1] = ask(r+1);

   int solcnt = check[m][0] - (l > 0 ? check[l-1][0] : 0);
   int sagcnt = check[m][1] - (r < n-1 ? check[r+1][1] : 0);
   if(l <= m-1 && solcnt > 0){
      //cout<<l<<" - "<<m-1<<" -> "<<solcnt<<endl;
      f(n, smallcnt, l, m-1, solcnt);
   }

   if(m+1 <= r && sagcnt > 0){
      //cout<<m+1<<" - "<<r<<" -> "<<sagcnt<<endl;
      f(n, smallcnt, m+1, r, sagcnt);
   }
}

long long kokbul(long long n){
   long long l = 1, r = n;
   while(l < r){
      long long m = (l + r)/2;

      if(m * m < n) l = m + 1;
      else r = m;
   }

   return l;
}

int find_best(int n) {
   int smallcnt = 0;
   int kok = kokbul(n) + 15;
   kok = min(kok, n);

   for(int i = 0; i < kok; i++){
      check[i] = ask(i);
      smallcnt = max(smallcnt, check[i][0] + check[i][1]);
   }
   for(int i = 0; i < kok; i++){
      if(check[i][0] + check[i][1] < smallcnt) small[i] = 1;
   }

   f(n, smallcnt, 0, n-1, smallcnt);
   int ans = -1;
   for(int i = 0; i < n; i++){
      if(small[i] == 1){
         if(check[i][0] == -1) check[i] = ask(i);
         if(check[i][0] + check[i][1] == 0){
            ans = i;
            break;
         }
      }
   }
   return ans;
}
/*
int main() {
   cin>>n;
   g.resize(n);

   for(int i = 0; i < n; i++) {
      cin>>g[i];
      if(g[i] < 1) {
         cerr << "Invalid rank " << g[i] << " at index " << i << endl;
         exit(0);
      }
   }

   int max_rank = *max_element(g.begin(), g.end());

   rank_count.resize(max_rank + 1, vector<int>(n + 1, 0));
   for(int r = 0; r <= max_rank; r++) {
      for(int i = 1; i <= n; i++) {
         rank_count[r][i] = rank_count[r][i - 1];
         if(g[i - 1] == r)
           rank_count[r][i]++;
      }
   }

   for(int i = 0; i <= n; i++)
      for(int r = 1; r <= max_rank; r++)
         rank_count[r][i] += rank_count[r - 1][i];

   int res = find_best(n);
   cout << res << endl << "Query count: " << query_count << endl;
   return 0;
}
*/
/*
int main() {
   mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
   int mx = 0;
   int t;
   cin>>t;
   while(t--){
      //cin>>n;
      //n = rng() % 55 + 7;
      n = 2e5 - rng() % 5000;
      g.resize(n);

      vector<int> cnts(3);
      cnts[0] = 1;
      cnts[1] = 3;
      cnts[2] = rng()%10 + 10;
      cnts[3] = rng()%20 + 400;
      cnts[4] = n - cnts[3] - cnts[2] - cnts[1] - cnts[0];

      for(int i = 0; i < n; i++){
         small[i] = 0;
         check[i][0] = check[i][1] = -1;
      }
      int ind = 0;
      for(int i = 0; i < n; i++){
         if(cnts[ind] == 0) ind++;
         g[i] = ind + 1;
         cnts[ind]--;
      }

      shuffle(g.begin(), g.end(), rng);

      for(int i = 0; i < n; i++) {
         if(g[i] < 1) {
            cerr << "Invalid rank " << g[i] << " at index " << i << endl;
            exit(0);
         }
      }

      int max_rank = *max_element(g.begin(), g.end());

      rank_count.clear();
      rank_count.resize(max_rank + 1, vector<int>(n + 1, 0));
      for(int r = 0; r <= max_rank; r++) {
         for(int i = 1; i <= n; i++) {
            rank_count[r][i] = rank_count[r][i - 1];
            if(g[i - 1] == r)
              rank_count[r][i]++;
         }
      }

      for(int i = 0; i <= n; i++)
         for(int r = 1; r <= max_rank; r++)
            rank_count[r][i] += rank_count[r - 1][i];

      int res = find_best(n);
      if(res == -1 || query_count > max_q){
         cout << res << endl << "Query count: " << query_count << endl;
      }
      mx = max(mx, query_count);
      query_count = 0;
   }
   cout<<mx<<endl;
   return 0;
}*/

Compilation message

prize.cpp: In function 'void f(int, int, int, int, int)':
prize.cpp:53:24: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
   53 |       for(int i = 0; i < delts.size(); i++){
      |                      ~~^~~~~~~~~~~~~~
# 결과 실행 시간 메모리 Grader output
1 Correct 31 ms 13996 KB Output is correct
2 Correct 28 ms 13812 KB Output is correct
3 Correct 28 ms 13748 KB Output is correct
4 Correct 23 ms 13256 KB Output is correct
5 Correct 31 ms 13740 KB Output is correct
6 Correct 30 ms 13812 KB Output is correct
7 Correct 30 ms 13820 KB Output is correct
8 Correct 26 ms 13748 KB Output is correct
9 Correct 31 ms 13900 KB Output is correct
10 Correct 27 ms 13820 KB Output is correct
# 결과 실행 시간 메모리 Grader output
1 Correct 30 ms 13748 KB Output is correct
2 Correct 31 ms 13748 KB Output is correct
3 Correct 26 ms 13740 KB Output is correct
4 Correct 19 ms 13324 KB Output is correct
5 Correct 28 ms 13820 KB Output is correct
6 Correct 26 ms 13748 KB Output is correct
7 Correct 26 ms 13748 KB Output is correct
8 Correct 27 ms 13748 KB Output is correct
9 Correct 28 ms 13812 KB Output is correct
10 Correct 27 ms 13816 KB Output is correct
11 Correct 50 ms 14016 KB Output is correct
12 Correct 51 ms 13748 KB Output is correct
13 Correct 52 ms 13748 KB Output is correct
14 Correct 35 ms 12368 KB Output is correct
15 Partially correct 164 ms 14008 KB Partially correct - number of queries: 5767
16 Partially correct 152 ms 13748 KB Partially correct - number of queries: 6160
17 Partially correct 150 ms 14024 KB Partially correct - number of queries: 5973
18 Partially correct 165 ms 13824 KB Partially correct - number of queries: 6128
19 Partially correct 145 ms 13748 KB Partially correct - number of queries: 5748
20 Correct 98 ms 12748 KB Output is correct
21 Partially correct 161 ms 13816 KB Partially correct - number of queries: 6147
22 Correct 129 ms 13740 KB Output is correct
23 Correct 37 ms 13744 KB Output is correct
24 Correct 41 ms 13816 KB Output is correct
25 Partially correct 145 ms 13808 KB Partially correct - number of queries: 5691
26 Partially correct 152 ms 14056 KB Partially correct - number of queries: 5632
27 Correct 36 ms 13808 KB Output is correct
28 Partially correct 151 ms 13748 KB Partially correct - number of queries: 5682
29 Correct 140 ms 13748 KB Output is correct
30 Partially correct 153 ms 13748 KB Partially correct - number of queries: 6106
31 Partially correct 160 ms 13996 KB Partially correct - number of queries: 5933
32 Correct 51 ms 13932 KB Output is correct
33 Correct 12 ms 12112 KB Output is correct
34 Partially correct 155 ms 13740 KB Partially correct - number of queries: 6175
35 Correct 45 ms 13816 KB Output is correct
36 Partially correct 162 ms 13812 KB Partially correct - number of queries: 6125
37 Correct 48 ms 13812 KB Output is correct
38 Correct 47 ms 13740 KB Output is correct
39 Partially correct 150 ms 13748 KB Partially correct - number of queries: 6030
40 Partially correct 149 ms 13812 KB Partially correct - number of queries: 5443
41 Partially correct 160 ms 13748 KB Partially correct - number of queries: 6051
42 Partially correct 159 ms 13852 KB Partially correct - number of queries: 6051
43 Partially correct 152 ms 13824 KB Partially correct - number of queries: 5947
44 Partially correct 151 ms 13812 KB Partially correct - number of queries: 6081
45 Partially correct 138 ms 13748 KB Partially correct - number of queries: 5560
46 Partially correct 139 ms 13748 KB Partially correct - number of queries: 6046
47 Partially correct 137 ms 13820 KB Partially correct - number of queries: 5606
48 Partially correct 146 ms 13996 KB Partially correct - number of queries: 6152
49 Partially correct 165 ms 13832 KB Partially correct - number of queries: 5995
50 Partially correct 180 ms 13808 KB Partially correct - number of queries: 6221
51 Partially correct 157 ms 13824 KB Partially correct - number of queries: 6162
52 Partially correct 158 ms 13740 KB Partially correct - number of queries: 6131
53 Correct 40 ms 13808 KB Output is correct
54 Partially correct 156 ms 13812 KB Partially correct - number of queries: 6114
55 Partially correct 160 ms 13748 KB Partially correct - number of queries: 5954
56 Partially correct 162 ms 13196 KB Partially correct - number of queries: 6337
57 Partially correct 149 ms 14000 KB Partially correct - number of queries: 6134
58 Partially correct 153 ms 13756 KB Partially correct - number of queries: 6162
59 Partially correct 159 ms 13324 KB Partially correct - number of queries: 6089
60 Partially correct 149 ms 13512 KB Partially correct - number of queries: 6020
61 Correct 46 ms 13324 KB Output is correct
62 Correct 41 ms 13256 KB Output is correct
63 Correct 39 ms 13320 KB Output is correct
64 Correct 37 ms 13248 KB Output is correct
65 Correct 33 ms 13812 KB Output is correct
66 Correct 28 ms 13324 KB Output is correct
67 Correct 26 ms 13268 KB Output is correct
68 Correct 35 ms 13860 KB Output is correct
69 Correct 27 ms 13440 KB Output is correct
70 Correct 27 ms 13320 KB Output is correct
71 Partially correct 198 ms 13740 KB Partially correct - number of queries: 7423
72 Correct 54 ms 13748 KB Output is correct
73 Partially correct 201 ms 13740 KB Partially correct - number of queries: 7239
74 Partially correct 201 ms 13748 KB Partially correct - number of queries: 7421
75 Correct 39 ms 13740 KB Output is correct
76 Partially correct 156 ms 13824 KB Partially correct - number of queries: 6578
77 Partially correct 172 ms 13844 KB Partially correct - number of queries: 7375
78 Correct 54 ms 13748 KB Output is correct
79 Correct 113 ms 14272 KB Output is correct
80 Partially correct 186 ms 13764 KB Partially correct - number of queries: 7340
81 Partially correct 191 ms 13748 KB Partially correct - number of queries: 7367
82 Partially correct 171 ms 13792 KB Partially correct - number of queries: 7174
83 Correct 40 ms 13816 KB Output is correct
84 Partially correct 167 ms 13740 KB Partially correct - number of queries: 6213
85 Partially correct 186 ms 13812 KB Partially correct - number of queries: 7300
86 Incorrect 214 ms 13980 KB Incorrect
87 Halted 0 ms 0 KB -