AC.

2023205/main.cpp

@@ -2,21 +2,13 @@
 // 并查集。并查集只关注双向连通性。
 
 struct Edge {
-    int next;
     unsigned short end;
     bool used_in_dfs;
 };
 
 Edge edges[1050000];
 char nodes_visited[65540];
-int head[65540], len;
-
-int add_edge(int start, int terminal) {
-    edges[++len].end = terminal;
-    edges[len].next = head[start];
-    head[start] = len;
-    return 0;
-}
+int pos[65540];
 
 int dfs(int start) {
     if (nodes_visited[start] >= 1) {
@@ -24,7 +16,7 @@ int dfs(int start) {
         return 0;
     }
     nodes_visited[start] = 1;
-    for (int j = head[start]; j != 0; j = edges[j].next) {
+    for (int j = pos[start]; j < pos[start + 1]; j++) {
         edges[j].used_in_dfs = dfs(edges[j].end);
     }
     return 1;
@@ -36,17 +28,17 @@ int dfs_with_dead_edge(int start, int dead_edge_start, int dead_edge_end) {
     }
     nodes_visited[start] = 1;
     if (start == dead_edge_start) {
-        for (int j = head[start]; j != 0; j = edges[j].next) {
+        for (int j = pos[start]; j < pos[start + 1]; j++) {
             if (edges[j].end == dead_edge_end) {
                 continue;
             }
-            dfs(edges[j].end);
+            dfs_with_dead_edge(edges[j].end, dead_edge_start, dead_edge_end);
         }
         return 0;
     }
 
-    for (int j = head[start]; j != 0; j = edges[j].next) {
-        dfs(edges[j].end);
+    for (int j = pos[start]; j < pos[start + 1]; j++) {
+        dfs_with_dead_edge(edges[j].end, dead_edge_start, dead_edge_end);
     }
 
     return 0;
@@ -55,15 +47,19 @@ int dfs_with_dead_edge(int start, int dead_edge_start, int dead_edge_end) {
 int main() {
     int N, M;
     scanf("%d %d", &N, &M);
+    int total_edge = 0;
     for (int start = 0; start < N; start++) {
+        pos[start] = total_edge;
         int edge_count;
         scanf("%d", &edge_count);
         for (int j = 0; j < edge_count; j++) {
-            int terminal;
-            scanf("%d", &terminal);
-            add_edge(start, terminal);
+            unsigned short terminal;
+            scanf("%hu", &terminal);
+            edges[pos[start] + j] = Edge{terminal, false};
         }
+        total_edge += edge_count;
     }
+    pos[N] = total_edge;
 
     dfs(0);
 
@@ -79,21 +75,10 @@ int main() {
 
     printf("1\n");
 
-    // for (int i = 0; i < M; i++) {
-    //     int start, end;
-    //     scanf("%d %d", &start, &end);
-    //     if (nodes_visited[end] == 2) {
-    //         printf("1\n");
-    //     }
-    //     else {
-    //         printf("0\n");
-    //     }
-    // }
-
     for (int i = 0; i < M; i++) {
         int start, end;
         scanf("%d %d", &start, &end);
-        for (int j = head[start]; j != 0; j = edges[j].next) {
+        for (int j = pos[start]; j < pos[start + 1]; j++) {
             if (edges[j].end == end) {
                 if (edges[j].used_in_dfs) {
                     for (int k = 0; k < N; k++) {
@@ -104,14 +89,16 @@ int main() {
                     bool connected = true;
                     for (int k = 0; k < N; k++) {
                         if (nodes_visited[k] < 1) {
-                            printf("0\n");
                             connected = false;
                             break;
                         }
                     }
                     if (connected) {
                         printf("1\n");
-                    } 
+                    }
+                    else {
+                        printf("0\n");
+                    }
                 }
                 else {
                     printf("1\n");

2023205/testdat.txt

@@ -2,3 +2,4 @@
 
 4 1 1 1 2 2 3 2 1 3 2 1 2 0 1
 
+4 1 1 1 2 2 3 2 1 3 2 1 2 1 2

2023206/brute_force.cpp

@@ -0,0 +1,21 @@
+#include <stdio.h>
+int stairs[100000] = {0};
+int M, K, H;
+long long total = 0;
+
+int main() {
+    scanf("%d %d %d", &M , &K, &H);
+    // stairs = new int[M];
+    for (int i = 0; i < M ; i++) {
+        scanf("%d", &stairs[i]);
+    }
+    for (int i = 0; i < M; i++) {
+        for (int j = i + 1; j <= i + K && j < M; j++) {
+            if (stairs[j] <= ((long long)stairs[i]) + H && stairs[j] >= stairs[i] - H) {
+                total++;
+            }
+        }
+    }
+    printf("%lld\n", total);
+    return 0;
+}

2023206/check_tree.py

@@ -0,0 +1,9 @@
+import random
+size = 1000
+arr = list(range(0, size))
+random.shuffle(arr)
+with open("random_num.txt", 'w') as f:
+    f.write("%d\n" % size)
+    for i in arr:
+        f.write("%d " % i)
+    f.write('\n')

2023206/correct.cpp

@@ -0,0 +1,35 @@
+#include <stdio.h>
+int* stairs = NULL;
+bool* visited = NULL;
+int M, K, H;
+long long total = 0;
+
+int dfs(int start) {
+    if (visited[start]) {
+        return 0;
+    }
+    visited[start] = true;
+    for (int i = 1; start + i < M && i <= K; i++) {
+        if (((stairs[start + i] - stairs[start]) < 0 ? stairs[start] - stairs[start + i] : stairs[start + i] - stairs[start]) <= H) {
+            total++;
+            dfs(start + i);
+        }
+    }
+    return 0;
+}
+
+int main() {
+    scanf("%d %d %d", &M , &K, &H);
+    stairs = new int[M];
+    visited = new bool[M];
+    for (int i = 0; i < M ; i++) {
+        scanf("%d", &stairs[i]);
+    }
+    for (int i = 0; i < M; i++) {
+        if (!visited[i]) {
+            dfs(i);
+        }
+    }
+    printf("%lld\n", total);
+    return 0;
+}

2023206/fuck.txt

@@ -0,0 +1,2 @@
+10 5 1
+2 3 8 0 1 7 9 5 6 4 

2023206/main.cpp

@@ -0,0 +1,140 @@
+#include <stdio.h>
+#define TREE_SIZE 65536
+#define NOTHING 65535
+struct TreeNode {
+    // int val;
+    unsigned short size;
+    unsigned short left;
+    unsigned short right;
+};
+
+TreeNode tree[TREE_SIZE] = {0};
+int vals[TREE_SIZE] = {0};
+int tree_root = NOTHING;
+int M, K, H;
+long long total = 0;
+int l = 0;
+
+int insert_node(int num, int pos) {
+    if (pos == NOTHING) {
+        // The tree_root is -1!
+        tree[l % K] = TreeNode{1, NOTHING, NOTHING};
+        tree_root = l % K;
+        vals[l % K] = num;
+        return l % K;
+    }
+    tree[pos].size++;
+    if (vals[pos] > num) {
+        if (tree[pos].left == NOTHING) {
+            tree[pos].left = l % K;
+            tree[l % K] = TreeNode{1, NOTHING, NOTHING};
+            vals[l % K] = num;
+            return l % K;
+        }
+        else {
+            return insert_node(num, tree[pos].left);
+        }
+    }
+    else {
+        if (tree[pos].right == NOTHING) {
+            tree[pos].right = l % K;
+            tree[l % K] = TreeNode{1, NOTHING, NOTHING};
+            vals[l % K] = num;
+            return l % K;
+        }
+        else {
+            return insert_node(num, tree[pos].right);
+        }
+    }
+}
+
+int delete_node(int num, int pos) {
+    if (pos == NOTHING) {
+        return NOTHING;
+    }
+
+    if (vals[pos] < num) {
+        tree[pos].size--;
+        tree[pos].right = delete_node(num, tree[pos].right);
+        return pos;
+    }
+
+    if (vals[pos] > num) {
+        tree[pos].size--;
+        tree[pos].left = delete_node(num, tree[pos].left);
+        return pos;
+    }
+
+    // If reached here, tree[pos].val == num, so we are going to delete tree[pos]
+    if (tree[pos].left == NOTHING) {
+        // The case when left is null, right is something
+        // and also the case when both left and right is null
+        return tree[pos].right;
+    }
+
+    if (tree[pos].right == NOTHING) {
+        // The case when left is something while right is null
+        return tree[pos].left;
+    }
+
+    // Here, we deal with the case that both children exist.
+    int parent = pos;
+    int child = tree[parent].right;
+    tree[parent].size--;
+    while (tree[child].left < NOTHING) {
+        parent = child;
+        child = tree[child].left;
+        tree[parent].size--;
+    }
+
+    if (parent == pos) {
+        tree[parent].right = tree[child].right;
+    }
+    else {
+        tree[parent].left = tree[child].right;
+    }
+
+    tree[child].left = tree[pos].left;
+    tree[child].right = tree[pos].right;
+    tree[child].size = tree[pos].size;
+    return child;
+}
+
+int count_less_than(long long target, int pos) {
+    if (pos == NOTHING) {
+        return 0;
+    }
+
+    if (vals[pos] < target) {
+        if (tree[pos].left == NOTHING) {
+            return 1 + count_less_than(target, tree[pos].right);
+        }
+        return tree[tree[pos].left].size + 1 + count_less_than(target, tree[pos].right);
+    }
+    if (vals[pos] > target) {
+        return count_less_than(target, tree[pos].left);
+    }
+
+    if (tree[pos].left == NOTHING) {
+        return 1;
+    }
+    return 1 + tree[tree[pos].left].size;
+}
+
+int main() {
+    scanf("%d %d %d", &M, &K, &H);
+    int num = 0;
+
+    for (l = 0; l < M; l++) {
+        scanf("%d", &num);
+        total += count_less_than(((long long)num) + H, tree_root) -
+                 count_less_than(num - H - 1, tree_root);
+        if (l >= K) {
+            tree_root = delete_node(vals[l % K], tree_root);
+        }
+        insert_node(num, tree_root);
+    }
+
+    printf("%lld\n", total);
+    return 0;
+}

2023206/rand_input.py

@@ -0,0 +1,24 @@
+import random
+import os
+# M = random.randint(10000, 100000)
+# K = random.randint(10000, 65536)
+# H = random.randint(10000, 100000)
+M = 10
+K = 5
+H = 1
+# arr = list(range(2147483647, 2147483647 - M, -1))
+arr = list(range(0, M))
+random.shuffle(arr)
+# print(arr)
+with open('fuck.txt', 'w') as f:
+    f.write(str(M)+' '+str(K)+' '+str(H)+'\n')
+    for i in arr:
+        f.write(str(i)+' ')
+    f.write('\n')
+
+print("main")
+os.system("./main.out < ./fuck.txt")
+print("\ncorrect")
+os.system("./correct.out < ./fuck.txt")
+print("\nbrute_force")
+os.system("./brute_force.out < ./fuck.txt")

2023206/random_num.txt

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

2023206/test_size.cpp

@@ -0,0 +1,9 @@
+#include <stdio.h>
+#include <assert.h>
+
+int main() {
+    int m, k, h;
+    scanf("%d %d %d", &m, &k, &h);
+    assert(m < 100000);
+    return 0;
+}

2023206/testdata.txt

@@ -0,0 +1,28 @@
+9 5 2
+6 8 5 7 4 3 9 2 10
+
+9 5 2 6 8 5 7 4 3 9 2 10
+
+ans: 14
+
+9 5 2 -6 -8 -5 -7 -4 -3 -9 -2 -10
+
+15 2 2
+1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
+
+15 2 2
+15 14 13 12 11 10 9 8 7 6 5 4 3 2 1
+
+15 20 2
+15 14 13 12 11 10 9 8 7 6 5 4 3 2 1
+
+10 5 1
+2147483639 2147483647 2147483641 2147483645 2147483643 2147483640 2147483642 2147483638 2147483644 2147483646
+
+10 5 1
+2 10 4 8 6 3 5 1 7 9 
+
+10 5 1
+5 3 6 7 4 1 9 2 0 8 
+
+10 5 1 5 3 6 7 4 1 9 2 0 8 

2023207/input.txt

@@ -0,0 +1,9 @@
+3
+3 2
+44 62 
+44 43 30 
+3 34 
+27 63 53 
+14 52 19
+
+3 3 2 44 62 44 43 30 3 34 27 63 53 14 52 19

2023207/main.cpp

@@ -0,0 +1,150 @@
+#include <math.h>
+#include <stdio.h>
+int p = 0;
+int m = 0, n = 0;
+double A[5][10000], Z[10000];
+
+double get_content(int row, int column) {
+    if (abs(row - column) > p / 2) {
+        return 0;
+    }
+    if (row < 0 || row >= n) {
+        return 0;
+    }
+    if (column < 0 || column >= n) {
+        return 0;
+    }
+    return A[(row - column + p / 2)][column];
+}
+
+int set_content(int row, int column, double val) {
+    if (abs(row - column) > p / 2) {
+        return 0;
+    }
+    if (row < 0 || row >= n) {
+        return 0;
+    }
+    if (column < 0 || column >= n) {
+        return 0;
+    }
+    A[(row - column + p / 2)][column] = val;
+    return 0;
+}
+
+// int output() {
+//     for (int i = 0; i < p; i++) {
+//         for (int j = 0; j < n; j++) {
+//             printf("%lf ", get_content(i, j));
+//         }
+//         printf("\n");
+//     }
+//     printf("\n");
+//     return 0;
+// }
+
+int outputZ() {
+    for (int i = 0; i < n; i++) {
+        printf("%.4lf ", Z[i]);
+    }
+    printf("\n");
+    return 0;
+}
+
+int main() {
+    scanf("%d", &p);
+    scanf("%d %d", &n, &m);
+    for (int i = 0; i < p / 2; i++) {
+        for (int j = p / 2 - i; j < n; j++) {
+            scanf("%lf", &A[i][j]);
+        }
+    }
+    for (int i = p / 2; i < p; i++) {
+        for (int j = 0; j < n - (i - p / 2); j++) {
+            scanf("%lf", &A[i][j]);
+        }
+    }
+
+    // printf("Readin\n");
+    // output();
+
+    for (int col = 0; col < n; col++) {
+        double diag_elem = get_content(col, col);
+        // make everything below the diag to 0 row by row
+        for (int row = col + 1; row < n; row++) {
+            double base = get_content(row, col);
+            if (base != 0) {
+                double coefficient = base / diag_elem;
+                set_content(row, col, -coefficient);
+                for (int l = col + 1; l < col + 3; l++) {
+                    set_content(row, l, get_content(row, l) - coefficient * get_content(col, l));
+                }
+            }
+        }
+    }
+
+    // printf("L ready\n");
+    // output();
+
+    for (int row = 0; row < n; row++) {
+        double diag_elem = get_content(row, row);
+        set_content(row, row, 1 / diag_elem);
+        for (int col = row + 1; col < n; col++) {
+            set_content(row, col, -get_content(row, col) / diag_elem);
+        }
+    }
+
+    // printf("All ready\n");
+    // output();
+
+    for (int i = 0; i < m; i++) {
+        // read in one col of z
+        for (int j = 0; j < n; j++) {
+            scanf("%lf", &Z[j]);
+        }
+
+        // printf("Readin\n");
+        // outputZ();
+
+        // calculate Z = L-1 * Z
+        // do this column by column
+        for (int j = 0; j < n; j++) {
+            // diag of U is always 1, z[j] * U[j][j] = z[j], so k doesn't have to equal to j
+            for (int k = j + 1; k < j + 3 && k < n; k++) {
+                Z[k] += Z[j] * get_content(k, j);
+            }
+        }
+
+        // printf("L-1 * Z\n");
+        // outputZ();
+
+        // calculate Z = D-1 * Z
+        for (int j = 0; j < n; j++) {
+            Z[j] = Z[j] * get_content(j, j);
+        }
+
+        // printf("D-1 L-1 * Z\n");
+        // outputZ();
+
+        // calculate Z =  U-1 * Z
+        // do this column by column
+        // printf("Starting U-1\n");
+        for (int j = n - 1; j >= 0; j--) {
+            // diag of U is always 1, z[j] * U[j][j] = z[j], so k doesn't have to equal to j
+            for (int k = j - 1; k > j - 3 && k >= 0; k--) {
+                Z[k] += Z[j] * get_content(k, j);
+            }
+            // outputZ();
+        }
+
+        // printf("U-1 D-1 L-1 * Z\n");
+        // outputZ();
+
+        // output
+        // for (int j = 0; j < n; j++) {
+        //     printf("%.4lf ", Z[j]);
+        // }
+        // printf("\n");
+        outputZ();
+    }
+    return 0;
+}

fuck.txt

@@ -0,0 +1,2 @@
+10 5 1
+2147483640 2147483646 2147483644 2147483639 2147483643 2147483647 2147483641 2147483638 2147483645 2147483642