判题失败了？

2023206/main.cpp

@@ -1,93 +1,78 @@
 #include <stdio.h>
-#define TREE_SIZE 65535
+#define TREE_SIZE 65536
 #define NOTHING 65535
 struct TreeNode {
-    int val;
+    // int val;
-    int size;
+    unsigned short size;
     unsigned short left;
     unsigned short right;
 };
 
 TreeNode tree[TREE_SIZE] = {0};
-int num_in_tree[TREE_SIZE] = {0};
+int vals[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[new_tree_node] = TreeNode{num, 1, NOTHING, NOTHING};
+        tree[l % K] = TreeNode{1, NOTHING, NOTHING};
-        tree_root = new_tree_node;
+        tree_root = l % K;
-        new_tree_node = (new_tree_node + 1) % TREE_SIZE;
+        vals[l % K] = num;
-        return 0;
+        return l % K;
     }
     tree[pos].size++;
-    if (tree[pos].val > num) {
+    if (vals[pos] > num) {
-        if (tree[pos].left >= NOTHING) {
+        if (tree[pos].left == NOTHING) {
-            tree[pos].left = new_tree_node;
+            tree[pos].left = l % K;
-            tree[new_tree_node] = TreeNode{num, 1, NOTHING, NOTHING};
+            tree[l % K] = TreeNode{1, NOTHING, NOTHING};
-            new_tree_node = (new_tree_node + 1) % TREE_SIZE;
+            vals[l % K] = num;
-            return 0;
+            return l % K;
         }
         else {
-            insert_node(num, tree[pos].left);
+            return insert_node(num, tree[pos].left);
-            return 0;
         }
     }
     else {
-        if (tree[pos].right >= NOTHING ) {
+        if (tree[pos].right == NOTHING) {
-            tree[pos].right = new_tree_node;
+            tree[pos].right = l % K;
-            tree[new_tree_node] = TreeNode{num, 1, NOTHING, NOTHING};
+            tree[l % K] = TreeNode{1, NOTHING, NOTHING};
-            new_tree_node = (new_tree_node + 1) % TREE_SIZE;
+            vals[l % K] = num;
-            return 0;
+            return l % K;
         }
         else {
-            insert_node(num, tree[pos].right);
+            return insert_node(num, tree[pos].right);
-            return 0;
         }
     }
 }
 
 int delete_node(int num, int pos) {
-    if (pos >= NOTHING) {
+    if (pos == NOTHING) {
-        return -1;
+        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 >= 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;
     }
@@ -109,49 +94,28 @@ int delete_node(int num, int pos) {
         tree[parent].left = tree[child].right;
     }
 
-    tree[pos].val = tree[child].val;
+    tree[child].left = tree[pos].left;
-    return pos;
+    tree[child].right = tree[pos].right;
-}
+    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 (tree[pos].val < target) {
+    if (vals[pos] < 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 (tree[pos].val > target) {
+    if (vals[pos] > target) {
         return count_less_than(target, tree[pos].left);
     }
 
-    // tree[pos].val == target
+    if (tree[pos].left == NOTHING) {
-
-    if (tree[pos].left >= NOTHING) {
         return 1;
     }
     return 1 + tree[tree[pos].left].size;
@@ -161,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);
-
+        total += count_less_than(((long long)num) + H, tree_root) -
-        // traverse(tree_root);
+                 count_less_than(num - H - 1, tree_root);
-        // printf("\n");
+        if (l >= K) {
-        // printf("num: %d, %d %d\n\n", num, count_less_than(num + H, tree_root),
+            tree_root = delete_node(vals[l % K], 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,19 +1,17 @@
 import random
 import os
-m = random.randint(10000, 100000)
+# M = random.randint(10000, 100000)
-k = random.randint(10000, 65535)
+# K = random.randint(10000, 65536)
-h = random.randint(10000, 100000)
+# H = random.randint(10000, 100000)
-# M = 10000
+M = 10
-# K = 1
+K = 5
-# H = 1
+H = 1
-arr = list(range(2147483647, 2147483647 - m, -1))
+# arr = list(range(2147483647, 2147483647 - M, -1))
-# print(len(arr) == M)
+arr = list(range(0, 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,3 +15,14 @@ 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

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

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

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