Try short

2023206/main.cpp

@@ -1,78 +1,93 @@
 #include <stdio.h>
-#define TREE_SIZE 65536
+#define TREE_SIZE 65535
 #define NOTHING 65535
 struct TreeNode {
-    // int val;
+    int val;
-    unsigned short size;
+    int size;
     unsigned short left;
     unsigned short right;
 };
 
 TreeNode tree[TREE_SIZE] = {0};
-int vals[TREE_SIZE] = {0};
+int num_in_tree[TREE_SIZE] = {0};
+int num_in_tree_head = 0, num_in_tree_tail = 0;
 int tree_root = NOTHING;
+int new_tree_node = 0;
 int M, K, H;
 long long total = 0;
-int l = 0;
+
+int enqueue(int num) {
+    num_in_tree[num_in_tree_tail] = num;
+    num_in_tree_tail = (num_in_tree_tail + 1) % TREE_SIZE;
+    return 0;
+}
+
+int dequeue() {
+    int ans = num_in_tree[num_in_tree_head];
+    num_in_tree_head = (num_in_tree_head + 1) % TREE_SIZE;
+    return ans;
+}
 
 int insert_node(int num, int pos) {
-    if (pos == NOTHING) {
+    if (pos >= NOTHING) {
         // The tree_root is -1!
-        tree[l % K] = TreeNode{1, NOTHING, NOTHING};
+        tree[new_tree_node] = TreeNode{num, 1, NOTHING, NOTHING};
-        tree_root = l % K;
+        tree_root = new_tree_node;
-        vals[l % K] = num;
+        new_tree_node = (new_tree_node + 1) % TREE_SIZE;
-        return l % K;
+        return 0;
     }
     tree[pos].size++;
-    if (vals[pos] > num) {
+    if (tree[pos].val > num) {
-        if (tree[pos].left == NOTHING) {
+        if (tree[pos].left >= NOTHING) {
-            tree[pos].left = l % K;
+            tree[pos].left = new_tree_node;
-            tree[l % K] = TreeNode{1, NOTHING, NOTHING};
+            tree[new_tree_node] = TreeNode{num, 1, NOTHING, NOTHING};
-            vals[l % K] = num;
+            new_tree_node = (new_tree_node + 1) % TREE_SIZE;
-            return l % K;
+            return 0;
         }
         else {
-            return insert_node(num, tree[pos].left);
+            insert_node(num, tree[pos].left);
+            return 0;
         }
     }
     else {
-        if (tree[pos].right == NOTHING) {
+        if (tree[pos].right >= NOTHING ) {
-            tree[pos].right = l % K;
+            tree[pos].right = new_tree_node;
-            tree[l % K] = TreeNode{1, NOTHING, NOTHING};
+            tree[new_tree_node] = TreeNode{num, 1, NOTHING, NOTHING};
-            vals[l % K] = num;
+            new_tree_node = (new_tree_node + 1) % TREE_SIZE;
-            return l % K;
+            return 0;
         }
         else {
-            return insert_node(num, tree[pos].right);
+            insert_node(num, tree[pos].right);
+            return 0;
         }
     }
 }
 
 int delete_node(int num, int pos) {
-    if (pos == NOTHING) {
+    if (pos >= NOTHING) {
-        return NOTHING;
+        return -1;
     }
 
-    if (vals[pos] < num) {
+    if (tree[pos].val < num) {
         tree[pos].size--;
         tree[pos].right = delete_node(num, tree[pos].right);
         return pos;
     }
 
-    if (vals[pos] > num) {
+    if (tree[pos].val > 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) {
+    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) {
+    if (tree[pos].right >= NOTHING) {
         // The case when left is something while right is null
         return tree[pos].left;
     }
@@ -94,28 +109,49 @@ int delete_node(int num, int pos) {
         tree[parent].left = tree[child].right;
     }
 
-    tree[child].left = tree[pos].left;
+    tree[pos].val = tree[child].val;
-    tree[child].right = tree[pos].right;
+    return pos;
-    tree[child].size = tree[pos].size;
-    return child;
 }
 
-int count_less_than(long long target, int pos) {
+int traverse(int pos) {
-    if (pos == NOTHING) {
+    // printf("%d %d(", tree[pos].val, tree[pos].size);
+    // printf("%d(", tree[pos].val);
+    // if (tree[pos].left >= 0) {
+    //     printf("l%d:", tree[pos].val);
+    //     traverse(tree[pos].left);
+    // }
+    // if (tree[pos].right >= 0) {
+    //     printf("r%d:", tree[pos].val);
+    //     traverse(tree[pos].right);
+    // }
+    // printf(")");
+    if (pos < 0) {
+        return 0;
+    }
+    traverse(tree[pos].left);
+    printf("%d ", tree[pos].val);
+    traverse(tree[pos].right);
     return 0;
 }
 
-    if (vals[pos] < target) {
+int count_less_than(long long target, int pos) {
-        if (tree[pos].left == NOTHING) {
+    if (pos >= NOTHING) {
+        return 0;
+    }
+
+    if (tree[pos].val < 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) {
+    if (tree[pos].val > target) {
         return count_less_than(target, tree[pos].left);
     }
 
-    if (tree[pos].left == NOTHING) {
+    // tree[pos].val == target
+
+    if (tree[pos].left >= NOTHING) {
         return 1;
     }
     return 1 + tree[tree[pos].left].size;
@@ -125,16 +161,38 @@ int main() {
     scanf("%d %d %d", &M, &K, &H);
     int num = 0;
 
-    for (l = 0; l < M; l++) {
+    for (int i = 0; i < M; i++) {
         scanf("%d", &num);
-        total += count_less_than(((long long)num) + H, tree_root) -
+
-                 count_less_than(num - H - 1, tree_root);
+        // traverse(tree_root);
-        if (l >= K) {
+        // printf("\n");
-            tree_root = delete_node(vals[l % K], tree_root);
+        // printf("num: %d, %d %d\n\n", num, count_less_than(num + H, tree_root),
+        // if (i) {
+        //     total += count_less_than(num + H, tree_root) - count_less_than(num - H - 1,
+        //     tree_root);
+        // }
+
+        total += count_less_than(((long long)num) + H, tree_root) - count_less_than(num - H - 1, tree_root);
+        if (i >= K) {
+            tree_root = delete_node(dequeue(), tree_root);
         }
+        enqueue(num);
         insert_node(num, tree_root);
     }
 
     printf("%lld\n", total);
+
+    // int count = 0;
+    // int num = 0;
+    // scanf("%d", &count);
+    // for (int i = 0; i < count; i++) {
+    //     scanf("%d", &num);
+    //     insert_node(num, tree_root);
+    // }
+
+    // for (int i = 0; i < count; i++) {
+    //     printf("%d ", count_less_than(i, tree_root));
+    // }
+
     return 0;
 }

2023206/rand_input.py

@@ -1,17 +1,19 @@
 import random
 import os
-# M = random.randint(10000, 100000)
+m = random.randint(10000, 100000)
-# K = random.randint(10000, 65536)
+k = random.randint(10000, 65535)
-# H = random.randint(10000, 100000)
+h = random.randint(10000, 100000)
-M = 10
+# M = 10000
-K = 5
+# K = 1
-H = 1
+# H = 1
-# arr = list(range(2147483647, 2147483647 - M, -1))
+arr = list(range(2147483647, 2147483647 - m, -1))
-arr = list(range(0, M))
+# print(len(arr) == M)
+arr.append(0)
+m += 1
 random.shuffle(arr)
 # print(arr)
 with open('fuck.txt', 'w') as f:
-    f.write(str(M)+' '+str(K)+' '+str(H)+'\n')
+    f.write(str(m)+' '+str(k)+' '+str(h)+'\n')
     for i in arr:
         f.write(str(i)+' ')
     f.write('\n')

2023206/testdata.txt

@@ -15,14 +15,3 @@ ans: 14
 
 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

@@ -1,9 +0,0 @@
-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

@@ -1,158 +0,0 @@
-#include <stdio.h>
-int p = 0;
-int m = 0, n = 0;
-double A[5][10000] = {0}, Z[10000] = {0};
-
-double get_content(int row, int column) {
-    if (row - column > 2 || row - column < -2) {
-        return 0;
-    }
-    if (row < 0 || row >= n) {
-        return 0;
-    }
-    if (column < 0 || column >= n) {
-        return 0;
-    }
-    return A[(row - column + 2)][column];
-}
-
-int set_content(int row, int column, double val) {
-    if (row - column > 2 || row - column < -2) {
-        return 0;
-    }
-    if (row < 0 || row >= n) {
-        return 0;
-    }
-    if (column < 0 || column >= n) {
-        return 0;
-    }
-    A[(row - column + 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("%lf ", 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]);
-    //     }
-    // }
-    for (int i = 2 - p / 2; i <= 2; i++) {
-        for (int j = 2 - i; j < n; j++) {
-            scanf("%lf", &A[i][j]);
-        }
-    }
-    for (int i = 3; i <= 2 + p / 2; i++) {
-        for (int j = 0; j < n - (i - 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 < n; 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");
-    }
-    return 0;
-}

fuck.txt

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