publish frontier_cs (reconvert) (part 20)

frontier_cs/problems/27/testdata/8.in

@@ -0,0 +1 @@
+30 30

frontier_cs/problems/27/testdata/9.in

@@ -0,0 +1 @@
+200 500

frontier_cs/problems/28/config.yaml

@@ -0,0 +1,8 @@
+type: interactive
+time: 1s
+memory: 512m
+subtasks:
+  - score: 100
+    n_cases: 10
+interactor: interactor.cc
+checker_type: testlib

frontier_cs/problems/28/interactor.cc

@@ -0,0 +1,106 @@
+#include "testlib.h"
+#include <iostream>
+#include <vector>
+#include <algorithm>
+#include <string>
+#include <map>
+
+using namespace std;
+
+string s[30][1010];
+char current[15];
+int num[30];
+int cnt = 0;
+map<string, int>vis;
+
+void dfs(int now, int start){
+  if(cnt >= 1000)return;
+  if(now >= 10){
+    cnt++;
+    for(int i = 0; i < 10; i++){
+      s[start][cnt] += current[i];
+    }
+    return;
+  }
+  if(now == 0){
+    current[now] = (char)('a'+start);
+    dfs(now+1, start);
+  }
+  else{
+    for(int i = 0; i < 26; i++){
+      current[now] = (char)('a'+i);
+      dfs(now+1, start);
+    }
+  }
+}
+
+int main(int argc, char *argv[]) {
+  /*
+   * inf: input
+   * ouf: contestant output
+   * ans: standard output
+   */
+  registerInteraction(argc, argv);
+  
+  for(int i = 0; i < 26; i++){
+    cnt = 0;
+    dfs(0, i);
+  }
+  int t = inf.readInt(), n = inf.readInt();
+  for(int i = 0; i < 26; i++){
+    num[i] = inf.readInt();
+  }
+  cout<<t<<endl;
+  cout.flush();
+  cout<<n<<endl;
+  cout.flush();
+  int sumk = 0;
+  for(int i = 1; i <= 4000; i++){
+    string operation = ouf.readWord();
+    if(operation == "query"){
+      string qs = ouf.readWord();
+      if(qs.length() >= 10)quitf(_wa, "Invalid query");
+      int k = ouf.readInt(1, n); 
+      sumk += k;
+      int start = qs[0]-'a';
+
+      int match_cnt = 0;
+      string ret[1010];
+      for(int j = 1; j <= num[start]; j++){
+        int match = 1;
+        for(int t = 0; t < qs.length(); t++){
+          if(s[start][j][t] != qs[t])match = 0;
+        }
+        if(match){
+          match_cnt++;
+          ret[match_cnt] = s[start][j];
+          if(match_cnt == k)break;
+        }
+      }
+      cout<<match_cnt<<" ";
+      for(int j = 1; j <= match_cnt; j++){
+        cout<<ret[j]<<" ";
+      }
+      cout<<endl;
+      cout.flush();
+    }
+    else if(operation == "answer"){
+      for(int j = 1; j <= n; j++){
+        string answers = ouf.readWord();
+        int start = answers[0]-'a';
+        if(answers > s[start][num[start]])quitf(_wa, "Invalid answer");
+        if(vis[answers])quitf(_wa, "Repeated answer");
+        vis[answers] = 1;
+      }
+      double score = (4000.0-1.0*sumk)/(4000.0-2400.0);
+      double unbounded_score = max(0.0, score);
+      score = min(score, 1.0);
+      score = max(score, 0.0);
+      quitp(score, "Ratio: %.3lf, RatioUnbounded: %.3lf", score, unbounded_score);
+    }
+    else{
+      quitf(_wa, "Invalid operation");
+    }
+  }
+  quitf(_wa, "Too many queries");
+}

frontier_cs/problems/28/statement.txt

@@ -0,0 +1,60 @@
+Hacking the Project
+Input file: standard input
+Output file: standard output
+Time limit: 1 second
+Memory limit: 512 mebibytes
+This is an interactive problem.
+Lewis is one of the developers of the new programming language called DiverC. The main feature of the
+program written in this language is that the code consists of pairwise distinct words. The compiler of
+DiverC developed by Lewis is, of course, written in DiverC and consists ofN pairwise distinct words.
+Lewis is using the DiverC online autofill service. But Lewis has made one serious mistake: he forgot to
+switch the “use my data for the improvement of the service database” function off. And Lewis was the
+first person who registered on this service, so now the service contains only the words from his compiler.
+Hacker Fernando wants to know all the words Lewis used in the compiler. So he registered at the DiverC
+online autofill service (wisely switching the dangerous function off), and now, for each prefixS and integer
+K entered by Fernando, the service returns, in lexicographic order, the firstK words from Lewis’s code
+that begin with the prefixS. If there are onlyk < Kwords, the service gives out onlyk words (but the
+service usage counter increases byK even in this case).
+Fernando checked the scripts used for the online service and found that one user is limited with the total value ofK in all queries. He wants to determine allN words used by Lewis with several queries
+such as the sum ofK in those queries is as less as possible.
+Can you help him?
+Interaction Protocol
+In the beginning, your program shall read one integerT /emdash.cyr the number of the test cases to be processed
+(1 ≤T ≤5).
+At the beginning of each test case, the jury program tells one integerN /emdash.cyr the number of the words in
+Lewis’s DiverC compiler (1 ≤N ≤1 000).
+Your program can then make two types of requests:
+• query S K /emdash.cyr getK (1 ≤ K ≤ N) lexicographically minimal words starting with prefix S
+(1 ≤|S|≤ 10). If the dictionary contains onlyk such words, where k < K, the answer to the
+query will containk words. The response to the query will be one line of the formkS1S2 . . . Sk,
+where k is the number of the words (0 ≤k ≤K), and thenk words Si in lexicographic order follow.
+• answer S1 S2 ...SN /emdash.cyr tell the full Lewis’s dictionary. After the wordanswer you shall print allN
+words in an arbitrary order separated by spaces. There will be no response from the jury program
+to this request, and your program must then continue with the next test case or exit if the current
+test case was the last one.
+The words in Lewis’s code are composed of lowercase English letters. The length of words is between 1
+to 10 characters. All words in Lewis’s code are pairwise distinct.
+The sum ofK for all queries of the first type for each test should be as less as possible. Your score will be determined by the number of this value. If this value is smaller, you will get a higher score if your final answer is correct.
+If value is greater than 4000, the solution will get 0 points. 
+Violating the interaction protocol or exceeding the limits for the sum ofK cause the “Wrong answer”
+verdict.
+Make sure you print the newline character after each query and flush the output stream buffer (flush
+languagecommand)aftereachrequest.Otherwise,thesolutionmaygettheidlenesslimitexceededverdict.
+Note that the jury program isadaptive, i.e. the set of Lewis’s words may be generated at the runtime,
+but the set is guaranteed to be consistent with the answers to previous queries.
+Page 1 of 2Example
+standard input standard output
+1
+4
+1 aaa
+2 aaa aba
+1 cxyxy
+0
+1 czzzz
+query a 1
+query a 4
+query c 1
+query cy 1
+query cz 1
+answer aaa aba czzzz cxyxy
+Page 2 of 2

frontier_cs/problems/28/testdata/1.ans

@@ -0,0 +1 @@
+2

frontier_cs/problems/28/testdata/1.in

@@ -0,0 +1,3 @@
+1
+1000
+37 43 97 96 53 78 10 92 13 66 64 81 35 7 0 28 84 49 40 27 0 0 0 0 0 0

frontier_cs/problems/28/testdata/10.ans

@@ -0,0 +1 @@
+38

frontier_cs/problems/28/testdata/10.in

@@ -0,0 +1,3 @@
+1
+1000
+32 2 16 8 128 32 8 16 4 2 8 4 8 16 4 32 1 256 8 8 407 0 0 0 0 0

frontier_cs/problems/28/testdata/2.ans

@@ -0,0 +1 @@
+24

frontier_cs/problems/28/testdata/2.in

@@ -0,0 +1,3 @@
+1
+1000
+24 65 83 73 42 82 65 12 93 92 19 30 5 34 82 14 1 44 3 16 53 39 29 0 0 0

frontier_cs/problems/28/testdata/3.ans

@@ -0,0 +1 @@
+31

frontier_cs/problems/28/testdata/3.in

@@ -0,0 +1,3 @@
+1
+1000
+71 2 56 90 49 7 4 2 86 23 49 95 85 49 85 0 88 14 49 6 21 69 0 0 0 0

frontier_cs/problems/28/testdata/4.ans

@@ -0,0 +1 @@
+36

frontier_cs/problems/28/testdata/4.in

@@ -0,0 +1,3 @@
+1
+1000
+37 43 80 74 7 29 53 18 85 46 64 97 82 17 45 49 72 82 20 0 0 0 0 0 0 0

frontier_cs/problems/28/testdata/5.ans

@@ -0,0 +1 @@
+68

frontier_cs/problems/28/testdata/5.in

@@ -0,0 +1,3 @@
+1
+1000
+34 68 53 83 6 36 65 30 58 61 51 89 15 7 84 2 27 99 61 54 17 0 0 0 0 0

frontier_cs/problems/28/testdata/6.ans

@@ -0,0 +1 @@
+32

frontier_cs/problems/28/testdata/6.in

@@ -0,0 +1,3 @@
+1
+1000
+512 256 128 64 32 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0

frontier_cs/problems/28/testdata/7.ans

@@ -0,0 +1 @@
+60

frontier_cs/problems/28/testdata/7.in

@@ -0,0 +1,3 @@
+1
+1000
+512 256 128 64 32 8 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

frontier_cs/problems/28/testdata/8.ans

@@ -0,0 +1 @@
+22

frontier_cs/problems/28/testdata/8.in

@@ -0,0 +1,3 @@
+1
+1000
+64 512 2 32 256 134 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

frontier_cs/problems/28/testdata/9.ans

@@ -0,0 +1 @@
+2

frontier_cs/problems/28/testdata/9.in

@@ -0,0 +1,3 @@
+1
+1000
+2 32 4 512 2 16 8 32 128 1 16 64 4 179 0 0 0 0 0 0 0 0 0 0 0 0

frontier_cs/problems/3/config.yaml

@@ -0,0 +1,8 @@
+type: interactive
+time: 10s
+memory: 1024m
+# A custom checker is required for the special scoring.
+interactor: interactor.cc
+subtasks:
+  - score: 100
+    n_cases: 20

frontier_cs/problems/3/interactor.cc

@@ -0,0 +1,121 @@
+#include "testlib.h"
+#include <vector>
+#include <string>
+#include <cmath>
+
+namespace {
+    constexpr int MAX_N = (int)1E5 + 10, SINGLE_QUERY_LIM = (int)1E7,
+                  TOTAL_ROUND_LIM = (int)1E7, TOTAL_QUERY_LIM = (int)3E8;
+    int subtask, n;
+    int cnt_query, cnt_round;
+    int inter[SINGLE_QUERY_LIM+10];
+    
+    // Helper to ensure conditions and quit if they fail
+    void Ensure(bool condition, const char* fail_message) {
+        if (!condition){
+            quitf(_wa, fail_message);
+        }
+    }
+
+    int p[MAX_N], q[MAX_N], vis[MAX_N], an;
+    
+    int flip(int u) {
+        u = q[u];
+        if (vis[u] ^= 1) {
+            an += vis[u - 1] + vis[u + 1];
+        } else {
+            an -= vis[u - 1] + vis[u + 1];
+        }
+        return an || (vis[1] && vis[n]);
+    }
+    
+    bool check(int c1[], int c2[]) {
+        int opt = -1;
+        for (int i = 0; i < n; i++)
+            if (c1[i] == c2[0]) {
+                opt = i;
+                break;
+            }
+        if (opt == -1) return false;
+        
+        bool f1 = true, f2 = true;
+        for (int i = 1, op1 = opt, op2 = opt; i < n; i++) {
+            op1++; op2--;
+            if (op1 >= n) op1 -= n;
+            if (op2 < 0) op2 += n;
+            if (c1[op1] != c2[i]) f1 = false;
+            if (c1[op2] != c2[i]) f2 = false;
+            if ((!f1) && (!f2)) return false;
+        }
+        return true;
+    }
+
+    double f(double x) {
+        return std::min(std::max(std::log2(x), 0.0), 8.0);
+    }
+    
+    double lambda(int t, int Q) {
+        return std::max(0.0, 1 - 0.1 * (f(t / 18.0) + f(Q / 1.5E7)));
+    }
+
+} // namespace
+
+void input_inter(int N){
+    for(int i = 0; i < N; i++)
+        inter[i] = ouf.readInt();
+}
+
+void output_inter(const int N){
+    std::vector<int> temp_vec;
+    for (int i=0; i<N; ++i) temp_vec.push_back(inter[i]);
+    println(temp_vec);
+}
+
+void query(const int N) {
+    for (int i = 0; i < N; i++) {
+        int u = inter[i];
+        Ensure(1 <= u && u <= n, "Query value out of range [1, n]");
+        inter[i] = flip(u);
+    }
+    output_inter(N);
+}
+
+int main(int argc, char* argv[]) {
+    registerInteraction(argc, argv);
+    subtask = inf.readInt();
+    n = inf.readInt();
+    for (int i = 0; i < n; i++) {
+        p[i] = ans.readInt();
+        q[p[i]] = i + 1;
+    }
+
+    inter[0] = subtask;
+    inter[1] = n;
+    output_inter(2);
+    
+    int N;
+    while (true) {
+        N = ouf.readInt();
+        if (N == -1) {
+            input_inter(n);
+            Ensure(check(p, inter), "Final answer is incorrect.");
+            break;
+        } else {
+            Ensure(N <= SINGLE_QUERY_LIM, "Single query size limit exceeded.");
+            cnt_round += 1;
+            cnt_query += N;
+            Ensure(cnt_round <= TOTAL_ROUND_LIM, "Total round limit exceeded.");
+            Ensure(cnt_query <= TOTAL_QUERY_LIM, "Total query limit exceeded.");
+            input_inter(N);
+            query(N);
+        }
+    }
+    
+    double score_ratio = lambda(cnt_round, cnt_query);
+    
+    // Use quitp with a formatted message that includes the "Ratio:" tag
+    quitp(score_ratio, "Correct. Rounds: %d, Queries: %d. Ratio: %.4f", cnt_round, cnt_query, score_ratio);
+    
+    return 0;
+}
+

frontier_cs/problems/3/statement.txt

@@ -0,0 +1,69 @@
+This is an interactive question.
+
+time limit: 10 seconds (up to 5 seconds for interactive library)
+Space limitations: 1GB (up to 64MB for interactive library)
+
+Description
+Hope City is a city built on a floating island. At the edge of the floating island, there are n lamp sockets evenly distributed, forming a ring shape. Each lamp holder is labeled with a number between 1 and n, and forms an arrangement of length n in a clockwise direction p1, p2,..., pn. You don't know this arrangement and hope to restore it through interaction with the system.
+
+You can ask the system to switch the state of a set of lamp holders at a time (if it was not originally lit, it will be lit; if it was originally lit, it will be extinguished).
+
+The system will maintain a set of currently lit lamp holders S (initially empty) internally. You cannot directly see the contents of the set, but you can obtain the following information through interaction:
+
+You can submit a set of operations at once (i.e. a series of target IDs for wick input), and the system will process each of these operations one by one:
+
+- If a lamp holder is not in S, it will be lit up after inserting the wick (add into S);
+- If a lamp holder is already in S, it will be extinguished up after inserting the wick (remove it from S);
+- After each operation, the system will record whether there is a pair of adjacent lamp holders on the ring in the current set S, and return the records of all operations together.
+After you submit a set of operations at once and receive the returned records, S will not be cleared, but will continue to serve as the initial set for the next set of operations.
+
+Input
+One line, contains two integers, subtask, n, representing the subtask ID and the length of the loop;
+
+Implementation Details
+To ask a query, output one line. First output a number L followed by a space, then print a sequence of L integers ranging from 1 to n separated by a space. 
+After flushing your output, your program should read a sequence of L integers, indicating whether there are adjacent pairs in S after each operation.
+Specifically, The system will maintain a set S, which is initially the result of the previous query (i.e. not reset), and sequentially scans each element u in this query:
+If u is not in S when scanned, perform an operation to light up u so that u is in S; if u is in S when scanned, perform an operation to extinguish u so that u is not in S. Then report an integer indicating whether there are adjacent pairs in S after this operation(0: does not exist; 1: exist).
+
+If you want to guess the permutation, output one line. First output -1 followed by a space, then print a permutation of n separated by a space, representing the arrangement of lamp holder numbers p1~pn. Since the ring has no starting point or direction, any cyclic shift of p1~pn or p1~pn is considered correct. After flushing your output, your program should exit immediately.
+
+Note that the answer for each test case is pre-determined. That is, the interactor is not adaptive. Also note that your guess does not count as a query.
+
+To flush your output, you can use:
+fflush(stdout) (if you use printf) or cout.flush() (if you use cout) in C and C++.
+
+Subtask
+Subtask 1 (10 points): Ensure n=1000.
+Subtask 2 (90 points): Ensure n=10 ^ 5.
+
+For a testcase, if your interaction process is illegal or the returned answer is incorrect, you will directly receive 0 points.
+
+Otherwise, record the total number of times you call query as t, and record the sum of the number of operations you perform each time when calling query as Q.
+
+Your score ratio lambda will be calculated according to the following formula:
+lambda=max (0, 1-0.1 (f (t/18)+f (Q/ (1.5 * 10^7)))
+Where f (x)=min (max (log_2 (x), 0), 8)
+Then, if the subtask where this testcase is located has a maximum score of S, then you will get lambda * S.
+
+The total number of times you call query cannot exceed 10 ^ 7, and the sum of the number of operations you perform each time when calling 'query' cannot exceed 3 * 10 ^ 8.
+To prevent unexpected behavior caused by a large vector, you also need to ensure that the number of operations in a single query call always does not exceed 10 ^ 7.
+
+Interactive Example
+Assuming n=4 and the arrangement of lamp holder is [2,4,1,3], the following is a valid interaction process:
+
+Player Program | Interaction Library | Description
+- | Call solve (4, 0) | Start the interaction process
+Call query ([1, 2]) | Return [0, 0] | Found that the two lamp holders with numbers 1 and 2 are not adjacent on the ring
+Call query ([1, 2]) | Return [0, 0] | extinguish 1,2
+Call query ([1, 3]) | Return [0, 1] | Found that two lamp holders with numbers 1 and 3 are adjacent on the ring
+Call query ([1, 3]) | Return [0, 0] | extinguish 1,3
+Call query ([1, 4]) | Return [0, 1] | Found that two lamp holders with numbers 1,4 are adjacent on the ring
+Call query ([1, 4]) | Return [0, 0] | extinguish 1,4
+Call query ([2, 3]) | Return [0, 1] | Found that two lamp holders with numbers 2 and 3 are adjacent on the ring
+Call query ([2, 3]) | Return [0, 0] | extinguish 2,3
+Call query ([2, 4]) | Return [0, 1] | Found that two lamp holders with numbers 2 and 4 are adjacent on the ring
+Call query ([2, 4]) | Return [0, 0] | extinguish 2,4
+Call query ([3, 4]) | Return [0, 0] | Found that the two lamp holders with numbers 3 and 4 are not adjacent on the ring
+Call query ([3, 4]) | Return [0, 0] | extinguish 3,4
+Run ends and returns [1, 4, 2, 3] | Print interaction result to screen | Interaction ends, result is correct

frontier_cs/problems/3/testdata/1.ans

@@ -0,0 +1 @@
+3 1 4 2 7 5 8 6 11 9 12 10 15 13 16 14 19 17 20 18 23 21 24 22 27 25 28 26 31 29 32 30 35 33 36 34 39 37 40 38 43 41 44 42 47 45 48 46 51 49 52 50 55 53 56 54 59 57 60 58 63 61 64 62 67 65 68 66 71 69 72 70 75 73 76 74 79 77 80 78 83 81 84 82 87 85 88 86 91 89 92 90 95 93 96 94 99 97 100 98 103 101 104 102 107 105 108 106 111 109 112 110 115 113 116 114 119 117 120 118 123 121 124 122 127 125 128 126 131 129 132 130 135 133 136 134 139 137 140 138 143 141 144 142 147 145 148 146 151 149 152 150 155 153 156 154 159 157 160 158 163 161 164 162 167 165 168 166 171 169 172 170 175 173 176 174 179 177 180 178 183 181 184 182 187 185 188 186 191 189 192 190 195 193 196 194 199 197 200 198 203 201 204 202 207 205 208 206 211 209 212 210 215 213 216 214 219 217 220 218 223 221 224 222 227 225 228 226 231 229 232 230 235 233 236 234 239 237 240 238 243 241 244 242 247 245 248 246 251 249 252 250 255 253 256 254 259 257 260 258 263 261 264 262 267 265 268 266 271 269 272 270 275 273 276 274 279 277 280 278 283 281 284 282 287 285 288 286 291 289 292 290 295 293 296 294 299 297 300 298 303 301 304 302 307 305 308 306 311 309 312 310 315 313 316 314 319 317 320 318 323 321 324 322 327 325 328 326 331 329 332 330 335 333 336 334 339 337 340 338 343 341 344 342 347 345 348 346 351 349 352 350 355 353 356 354 359 357 360 358 363 361 364 362 367 365 368 366 371 369 372 370 375 373 376 374 379 377 380 378 383 381 384 382 387 385 388 386 391 389 392 390 395 393 396 394 399 397 400 398 403 401 404 402 407 405 408 406 411 409 412 410 415 413 416 414 419 417 420 418 423 421 424 422 427 425 428 426 431 429 432 430 435 433 436 434 439 437 440 438 443 441 444 442 447 445 448 446 451 449 452 450 455 453 456 454 459 457 460 458 463 461 464 462 467 465 468 466 471 469 472 470 475 473 476 474 479 477 480 478 483 481 484 482 487 485 488 486 491 489 492 490 495 493 496 494 499 497 500 498 503 501 504 502 507 505 508 506 511 509 512 510 515 513 516 514 519 517 520 518 523 521 524 522 527 525 528 526 531 529 532 530 535 533 536 534 539 537 540 538 543 541 544 542 547 545 548 546 551 549 552 550 555 553 556 554 559 557 560 558 563 561 564 562 567 565 568 566 571 569 572 570 575 573 576 574 579 577 580 578 583 581 584 582 587 585 588 586 591 589 592 590 595 593 596 594 599 597 600 598 603 601 604 602 607 605 608 606 611 609 612 610 615 613 616 614 619 617 620 618 623 621 624 622 627 625 628 626 631 629 632 630 635 633 636 634 639 637 640 638 643 641 644 642 647 645 648 646 651 649 652 650 655 653 656 654 659 657 660 658 663 661 664 662 667 665 668 666 671 669 672 670 675 673 676 674 679 677 680 678 683 681 684 682 687 685 688 686 691 689 692 690 695 693 696 694 699 697 700 698 703 701 704 702 707 705 708 706 711 709 712 710 715 713 716 714 719 717 720 718 723 721 724 722 727 725 728 726 731 729 732 730 735 733 736 734 739 737 740 738 743 741 744 742 747 745 748 746 751 749 752 750 755 753 756 754 759 757 760 758 763 761 764 762 767 765 768 766 771 769 772 770 775 773 776 774 779 777 780 778 783 781 784 782 787 785 788 786 791 789 792 790 795 793 796 794 799 797 800 798 803 801 804 802 807 805 808 806 811 809 812 810 815 813 816 814 819 817 820 818 823 821 824 822 827 825 828 826 831 829 832 830 835 833 836 834 839 837 840 838 843 841 844 842 847 845 848 846 851 849 852 850 855 853 856 854 859 857 860 858 863 861 864 862 867 865 868 866 871 869 872 870 875 873 876 874 879 877 880 878 883 881 884 882 887 885 888 886 891 889 892 890 895 893 896 894 899 897 900 898 903 901 904 902 907 905 908 906 911 909 912 910 915 913 916 914 919 917 920 918 923 921 924 922 927 925 928 926 931 929 932 930 935 933 936 934 939 937 940 938 943 941 944 942 947 945 948 946 951 949 952 950 955 953 956 954 959 957 960 958 963 961 964 962 967 965 968 966 971 969 972 970 975 973 976 974 979 977 980 978 983 981 984 982 987 985 988 986 991 989 992 990 995 993 996 994 999 997 1000 998 

frontier_cs/problems/3/testdata/1.in

@@ -0,0 +1 @@
+1 1000

frontier_cs/problems/3/testdata/10.in

@@ -0,0 +1 @@
+2 100000

frontier_cs/problems/3/testdata/11.in

@@ -0,0 +1 @@
+2 100000

frontier_cs/problems/3/testdata/12.in

@@ -0,0 +1 @@
+2 100000

frontier_cs/problems/3/testdata/13.in

@@ -0,0 +1 @@
+2 100000

frontier_cs/problems/3/testdata/14.in

@@ -0,0 +1 @@
+2 100000

frontier_cs/problems/3/testdata/15.in

@@ -0,0 +1 @@
+2 100000

frontier_cs/problems/3/testdata/16.in

@@ -0,0 +1 @@
+2 100000

frontier_cs/problems/3/testdata/17.in

@@ -0,0 +1 @@
+2 100000

frontier_cs/problems/3/testdata/18.in

@@ -0,0 +1 @@
+2 100000