All wa...

2023206/main.cpp

@@ -1,35 +1,212 @@
 #include <stdio.h>
-int* stairs = NULL;
-bool* visited = NULL;
+#define TREE_SIZE 10000
+
+struct TreeNode {
+    int val;
+    int size;
+    int left;
+    int 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 = 0;
+int new_tree_node = 0;
 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);
-        }
-    }
+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 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);
+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) {
+    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;
+        }
+        else {
+            insert_node(num, tree[pos].left);
+            return 0;
         }
     }
-    printf("%lld", total);
+    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;
+        }
+        else {
+            insert_node(num, tree[pos].right);
+            return 0;
+        }
+    }
+}
+
+int delete_node(int num, int pos) {
+    if (pos < 0) {
+        return -1;
+    }
+
+    if (tree[pos].val < num) {
+        tree[pos].size--;
+        tree[pos].right = delete_node(num, tree[pos].right);
+        return pos;
+    }
+
+    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 < 0) {
+        // 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) {
+        // 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 >= 0) {
+        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[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(")");
+    return 0;
+}
+
+int count_less_than(int target, int pos) {
+    if (pos == -1) {
+        return 0;
+    }
+
+    if (tree[pos].val < target) {
+        if (tree[pos].left < 0) {
+            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) {
+        return count_less_than(target, tree[pos].left);
+    }
+
+    // tree[pos].val == target
+
+    if (tree[pos].left < 0) {
+        return 1;
+    }
+    return 1 + tree[tree[pos].left].size;
+}
+
+int count_greater_than(int target, int pos) {
+    if (pos == -1) {
+        return 0;
+    }
+
+    if (tree[pos].val > target) {
+        if (tree[pos].right < 0) {
+            return 1 + count_greater_than(target, tree[pos].left);
+        }
+        return tree[tree[pos].right].size + 1 + count_greater_than(target, tree[pos].left);
+    }
+    if (tree[pos].val < target) {
+        return count_greater_than(target, tree[pos].right);
+    }
+
+    // tree[pos].val == target
+
+    if (tree[pos].right < 0) {
+        return 1;
+    }
+    return tree[tree[pos].right].size + 1;
+}
+
+int main() {
+    scanf("%d %d %d", &M, &K, &H);
+    int num = 0;
+    scanf("%d", &num);
+    tree[tree_root] = TreeNode{num, 1, -1, -1};
+    new_tree_node = 1;
+    enqueue(num);
+
+    for (int i = 1; i < M; i++) {
+        scanf("%d", &num);
+        
+        // traverse(tree_root);
+        // printf("\n");
+        // printf("num: %d, %d %d\n\n", num, count_less_than(num + H, tree_root), count_less_than(num - H - 1, tree_root));
+        total += count_less_than(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", total);
+
+    // tree[0] = TreeNode{4, 1, -1, -1};
+    // new_tree_node = 1;
+
+    // insert_node(2, tree_root);
+    // insert_node(3, tree_root);
+    // insert_node(1, tree_root);
+    // insert_node(0, tree_root);
+    // traverse(tree_root);
+    // printf("\n");
+    // printf("%d", count_greater_than(1, tree_root));
+    // tree_root = delete_node(4, tree_root);
+    // traverse(tree_root);
+    // enqueue(1);
+    // enqueue(2);
+    // enqueue(3);
+    // printf("%d %d %d", dequeue(), dequeue(), dequeue());
+
     return 0;
 }

2023206/testdata.txt

@@ -0,0 +1,9 @@
+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
+
+15 2 2
+1 2 3 4 5 6 7 8 9 10 11 12 13 14 15