Remove unused code.

2023206/main.cpp

@@ -1,92 +1,78 @@
 #include <stdio.h>
-#define TREE_SIZE 50000
+#define TREE_SIZE 65536
+#define NOTHING 65535
 struct TreeNode {
-    int val;
-    int size;
-    int left;
-    int right;
+    // int val;
+    unsigned short size;
+    unsigned short left;
+    unsigned short right;
 };
 
 TreeNode tree[TREE_SIZE] = {0};
-int num_in_tree[TREE_SIZE] = {0};
-int num_in_tree_head = 0, num_in_tree_tail = 0;
-int tree_root = -1;
-int new_tree_node = 0;
+int vals[TREE_SIZE] = {0};
+int tree_root = NOTHING;
 int M, K, H;
 long long total = 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 l = 0;
 
 int insert_node(int num, int pos) {
-    if (pos < 0) {
+    if (pos == NOTHING) {
         // The tree_root is -1!
-        tree[new_tree_node] = TreeNode{num, 1, -1, -1};
-        tree_root = new_tree_node;
-        new_tree_node = (new_tree_node + 1) % TREE_SIZE;
-        return 0;
+        tree[l % K] = TreeNode{1, NOTHING, NOTHING};
+        tree_root = l % K;
+        vals[l % K] = num;
+        return l % K;
     }
     tree[pos].size++;
-    if (tree[pos].val > num) {
-        if (tree[pos].left < 0) {
-            tree[pos].left = new_tree_node;
-            tree[new_tree_node] = TreeNode{num, 1, -1, -1};
-            new_tree_node = (new_tree_node + 1) % TREE_SIZE;
-            return 0;
+    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 {
-            insert_node(num, tree[pos].left);
-            return 0;
+            return insert_node(num, tree[pos].left);
         }
     }
     else {
-        if (tree[pos].right < 0) {
-            tree[pos].right = new_tree_node;
-            tree[new_tree_node] = TreeNode{num, 1, -1, -1};
-            new_tree_node = (new_tree_node + 1) % TREE_SIZE;
-            return 0;
+        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 {
-            insert_node(num, tree[pos].right);
-            return 0;
+            return insert_node(num, tree[pos].right);
         }
     }
 }
 
 int delete_node(int num, int pos) {
-    if (pos < 0) {
-        return -1;
+    if (pos == NOTHING) {
+        return NOTHING;
     }
 
-    if (tree[pos].val < num) {
+    if (vals[pos] < num) {
         tree[pos].size--;
         tree[pos].right = delete_node(num, tree[pos].right);
         return pos;
     }
 
-    if (tree[pos].val > num) {
+    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 < 0) {
+    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 < 0) {
+    if (tree[pos].right == NOTHING) {
         // The case when left is something while right is null
         return tree[pos].left;
     }
@@ -95,7 +81,7 @@ int delete_node(int num, int pos) {
     int parent = pos;
     int child = tree[parent].right;
     tree[parent].size--;
-    while (tree[child].left >= 0) {
+    while (tree[child].left < NOTHING) {
         parent = child;
         child = tree[child].left;
         tree[parent].size--;
@@ -108,49 +94,28 @@ int delete_node(int num, int pos) {
         tree[parent].left = tree[child].right;
     }
 
-    tree[pos].val = tree[child].val;
-    return pos;
-}
-
-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;
+    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 < 0) {
+    if (pos == NOTHING) {
         return 0;
     }
 
-    if (tree[pos].val < target) {
-        if (tree[pos].left < 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 (tree[pos].val > target) {
+    if (vals[pos] > target) {
         return count_less_than(target, tree[pos].left);
     }
 
-    // tree[pos].val == target
-
-    if (tree[pos].left < 0) {
+    if (tree[pos].left == NOTHING) {
         return 1;
     }
     return 1 + tree[tree[pos].left].size;
@@ -160,38 +125,16 @@ int main() {
     scanf("%d %d %d", &M, &K, &H);
     int num = 0;
 
-    for (int i = 0; i < M; i++) {
+    for (l = 0; l < M; l++) {
         scanf("%d", &num);
-
-        // traverse(tree_root);
-        // printf("\n");
-        // 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);
+        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);
         }
-        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,12 +1,13 @@
 import random
 import os
-M = random.randint(10000, 100000)
-K = random.randint(10000, 100000)
-H = random.randint(10000, 100000)
-# M = 10000
-# K = 1
-# H = 1
-arr = list(range(2147483647, 2147483647 - M, -1))
+# 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:

2023206/testdata.txt

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

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