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 traverse(int pos) {
+    // 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;
 }
 
 int count_less_than(long long target, int pos) {
-    if (pos == NOTHING) {
+    if (pos >= NOTHING) {
         return 0;
     }
 
-    if (vals[pos] < target) {
+    if (tree[pos].val < target) {
-        if (tree[pos].left == NOTHING) {
+        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 

fuck.txt

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