DataStructureAndAlgorithm/2023206/main.cpp

#include <stdio.h>
#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 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) {
    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;
        }
    }
    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;
}