100!

.gitignore

@@ -7,4 +7,5 @@
 *.o
 *.dat
 *.ilk
-*.pdb
+*.pdb
+*.in

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 val;
-    int size;
+    unsigned short size;
-    int left;
+    unsigned short left;
-    int right;
+    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 tree_root = -1;
-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 < 0) {
+    if (pos == NOTHING) {
         // The tree_root is -1!
-        tree[new_tree_node] = TreeNode{num, 1, -1, -1};
+        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 < 0) {
+        if (tree[pos].left == NOTHING) {
-            tree[pos].left = new_tree_node;
+            tree[pos].left = l % K;
-            tree[new_tree_node] = TreeNode{num, 1, -1, -1};
+            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 < 0) {
+        if (tree[pos].right == NOTHING) {
-            tree[pos].right = new_tree_node;
+            tree[pos].right = l % K;
-            tree[new_tree_node] = TreeNode{num, 1, -1, -1};
+            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 < 0) {
+    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 < 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;
+    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 < 0) {
+    if (pos == NOTHING) {
         return 0;
     }
 
-    if (tree[pos].val < target) {
+    if (vals[pos] < target) {
-        if (tree[pos].left < 0) {
+        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 < 0) {
         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);
-
+        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,12 +1,13 @@
 import random
 import os
-M = random.randint(10000, 100000)
+# M = random.randint(10000, 100000)
-K = random.randint(10000, 100000)
+# 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))
+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 

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,150 @@
+#include <math.h>
+#include <stdio.h>
+int p = 0;
+int m = 0, n = 0;
+double A[5][10000], Z[10000];
+
+double get_content(int row, int column) {
+    if (abs(row - column) > p / 2) {
+        return 0;
+    }
+    if (row < 0 || row >= n) {
+        return 0;
+    }
+    if (column < 0 || column >= n) {
+        return 0;
+    }
+    return A[(row - column + p / 2)][column];
+}
+
+int set_content(int row, int column, double val) {
+    if (abs(row - column) > p / 2) {
+        return 0;
+    }
+    if (row < 0 || row >= n) {
+        return 0;
+    }
+    if (column < 0 || column >= n) {
+        return 0;
+    }
+    A[(row - column + p / 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("%.4lf ", 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]);
+        }
+    }
+
+    // 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 < col + 3; 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");
+        outputZ();
+    }
+    return 0;
+}

2023208/main.cpp

@@ -0,0 +1,179 @@
+#include <math.h>
+#include <stdio.h>
+#define EPSILON 1e-6
+
+double A[5051] = {0};
+double point_xs[101] = {0};
+int valid_point_num = 0;
+double t[101] = {0};
+int n, m;
+
+double get_num(int row, int col) {
+    if (col > row) {
+        return 0;
+    }
+    return A[row * (row + 1) / 2 + col];
+}
+
+double set_num(int row, int col, double content) {
+    if (col > row) {
+        return 0;
+    }
+    return A[row * (row + 1) / 2 + col] = content;
+}
+
+bool compare_double(long double a, long double b) {
+    return (a - b > 0 ? a - b : -(a - b)) < EPSILON;
+}
+
+double evaluate(double x, int highest) {
+    double ans = get_num(highest, highest);
+    for (int j = highest - 1; j >= 0; j--) {
+        ans *= x - point_xs[j];
+        ans += get_num(j, j);
+    }
+    return ans;
+}
+
+double evaluate_2(double x, int highest) {
+    double ans = t[highest];
+    for (int j = highest - 1; j >= 0; j--) {
+        ans *= x - point_xs[j];
+        ans += t[j];
+    }
+    return ans;
+}
+
+int display_mat() {
+    for (int i = 0; i < valid_point_num; i++) {
+        for (int j = 0; j < valid_point_num; j++) {
+            printf("%lf ", get_num(i, j));
+        }
+        printf("\n");
+    }
+    printf("\n");
+    return 0;
+}
+
+int main_2() {
+    double read_x, read_y;
+    bool found_duplicate = false;
+    for (int i = 0; i < n; i++) {
+        scanf("%lf %lf", &read_x, &read_y);
+        for (int j = 0; j < valid_point_num; j++) {
+            if (compare_double(read_x, point_xs[valid_point_num])) {
+                found_duplicate = true;
+                break;
+            }
+        }
+
+        if (!found_duplicate) {
+            point_xs[valid_point_num] = read_x;
+            t[valid_point_num] = read_y;
+            valid_point_num++;
+        }
+    }
+
+    // Prepare the matrix
+    for (int row = 0; row < valid_point_num; row++) {
+        set_num(row, 0, 1);
+        for (int col = 1; col <= row; col++) {
+            set_num(row, col, get_num(row, col - 1) * (point_xs[row] - point_xs[col - 1]));
+        }
+    }
+
+    // Solve for t
+    for (int row = 0; row < valid_point_num; row++) {
+        for (int i = 0; i < row; i++) {
+            t[row] -= t[i] * get_num(row, i);
+        }
+        if (!compare_double(t[row], 0)) {
+            t[row] /= get_num(row, row);
+        }
+        else {
+            t[row] = 0;
+        }
+    }
+
+    // Find for highest exponent
+    int highest = valid_point_num - 1;
+    for (; highest >= 0; highest--) {
+        if (!compare_double(t[highest], 0)) {
+            break;
+        }
+    }
+
+    printf("%d\n", highest);
+
+    // Evaluate
+    for (int i = 0; i < m; i++) {
+        double to_be_evaled = 0;
+        scanf("%lf", &to_be_evaled);
+        printf("%lf\n", evaluate_2(to_be_evaled, highest));
+    }
+    return 0;
+}
+
+int main_1() {
+    for (int i = 0; i < n; i++) {
+        bool found_duplicate = false;
+        double read_x, read_y;
+        scanf("%lf %lf", &read_x, &read_y);
+        for (int j = 0; j < valid_point_num; j++) {
+            if (compare_double(read_x, point_xs[j])) {
+                found_duplicate = true;
+                break;
+            }
+        }
+
+        if (!found_duplicate) {
+            point_xs[valid_point_num] = read_x;
+            set_num(valid_point_num, 0, read_y);
+            valid_point_num++;
+        }
+    }
+
+    // Go create the full table
+    for (int col = 1; col < valid_point_num; col++) {
+        int delta = col;
+        for (int row = col; row < valid_point_num; row++) {
+            set_num(row, col,
+                    (get_num(row, col - 1) - get_num(row - 1, col - 1)) /
+                        (point_xs[row] - point_xs[row - delta]));
+        }
+        if (compare_double(get_num(col, col) / 1000, 0)) {
+            set_num(col, col, 0);
+        }
+        // display_mat();
+    }
+
+    // Find the highest
+    int highest = valid_point_num - 1;
+    for (; highest >= 0; highest--) {
+        if (compare_double(get_num(highest, highest) / 1000, 0)) {
+            continue;
+        }
+        break;
+    }
+
+    printf("%d\n", highest);
+
+    double to_be_evaled = 0;
+    for (int i = 0; i < m; i++) {
+        scanf("%lf", &to_be_evaled);
+        printf("%lf\n", evaluate(to_be_evaled, highest));
+    }
+
+    return 0;
+}
+
+int main() {
+    scanf("%d %d", &n, &m);
+    if (n > 50) {
+        main_2();
+    }
+    else {
+        main_1();
+    }
+    return 0;
+}

2023208/vandermonde.cpp

@@ -0,0 +1,124 @@
+#include <stdio.h>
+#define EPSILON 1e-6
+struct Point {
+    double x, y;
+};
+
+double A[101][101] = {0};
+Point points[101] = {0};
+int valid_point_num = 0;
+int n = 0, m = 0;
+
+int display_matrix() {
+    for (int i = 0; i < valid_point_num; i++) {
+        for (int j = 0; j < valid_point_num; j++) {
+            printf("%lf ", A[i][j]);
+        }
+        printf("| %lf\n", points[i].y);
+    }
+    printf("\n");
+    return 0;
+}
+
+int display_result_vec() {
+    for (int i = 0; i < valid_point_num; i++) {
+        printf("%lf ", points[i].x);
+    }
+
+    printf("\n");
+    return 0;
+}
+
+bool compare_double(double a, double b) {
+    return (a - b > 0 ? a - b : -(a - b)) < EPSILON;
+}
+
+double evaluate(double x, int highest) {
+    double ans = points[highest].x;
+    for (int i = highest + 1; i < valid_point_num; i++) {
+        ans *= x;
+        ans += points[i].x;
+    }
+    return ans;
+}
+
+int main() {
+    // freopen("lambdaeight19.in", "r", stdin);
+    scanf("%d %d", &n, &m);
+    for (int i = 0; i < n; i++) {
+        bool found_duplicate = false;
+        double read_x, read_y;
+        scanf("%lf %lf", &read_x, &read_y);
+        for (int j = 0; j < valid_point_num; j++) {
+            if (compare_double(read_x, points[j].x)) {
+                found_duplicate = true;
+                break;
+            }
+        }
+
+        if (!found_duplicate) {
+            points[valid_point_num++] = Point {read_x, read_y};
+        }
+
+    }
+    
+    // vandermonde matrix
+    for (int i = 0; i < valid_point_num; i++) {
+        A[i][n - 1] = 1;
+        for (int j = valid_point_num - 2; j >= 0; j--) {
+            A[i][j] = points[i].x * A[i][j + 1];
+        }
+    }
+
+    // display_matrix();
+
+    // Gauss
+    for (int col = 0; col < valid_point_num; col++) {
+        for (int row = col + 1; row < valid_point_num; row++) {
+            if (compare_double(A[col][col], 0)) {
+                continue;
+            }
+            double coeff =  - A[row][col] / A[col][col];
+            A[row][col] = 0;
+            for (int i = col + 1; i < valid_point_num; i++) {
+                A[row][i] += coeff * A[col][i];
+            }
+            points[row].y += coeff * points[col].y;
+        }
+        // display_matrix();
+    }
+
+    // Solve for x
+    for (int i = valid_point_num - 1; i >= 0; i--) {
+        for (int j = valid_point_num - 1; j > i; j--) {
+            points[i].y -= points[j].x * A[i][j];
+        }
+        if (compare_double(points[i].y, 0)) {
+            points[i].x = 0;
+        } else {
+            points[i].x = points[i].y / A[i][i];
+        }
+        // display_result_vec();
+    }
+
+    // display_result_vec();
+
+    // Find highest
+    int highest = 0;
+    for (int i = 0; i < valid_point_num; i++) {
+        if (!compare_double(points[i].x, 0)) {
+            highest = i;
+            break;
+        }
+    }
+
+    printf("%d\n", valid_point_num - 1 - highest);
+
+    //Evaluate
+    for (int i = 0; i < m; i++) {
+        double to_be_evaled = 0;
+        scanf("%lf", &to_be_evaled);
+        printf("%lf\n", evaluate(to_be_evaled, highest));
+    }
+    return 0;
+}

2023209/input.txt

@@ -0,0 +1,2 @@
+4 5 0 1 1 1 0 2 4 2 1 2 1 5 1 3 4 2 2 3 1 1 0 3 4
+4 5 0 1 1 1 1 2 1 5 1 3 4 2 2 0 4 2 2 3 1 1 0 3 4

2023209/main.cpp

@@ -0,0 +1,164 @@
+#include <stdio.h>
+#include <queue>
+#include <functional>
+
+struct Point {
+    unsigned short name;
+    int known_shortest;
+    int time;
+
+    Point(int _name, int _known_shortest, int _time): name(_name), known_shortest(_known_shortest), time(_time) {}
+
+    Point() {};
+};
+
+template <class T>
+struct compare_point {
+    bool operator()(T &a, T &b) {
+        return a.known_shortest < b.known_shortest;
+    }
+};
+struct Edge{
+    unsigned short end, time, cost;
+};
+
+int N, M;
+unsigned short edges[1050000][3] = {0};
+// 边是否顺序？ 按开始点排序
+// 时间限制最大是多少？ 超过unsigned short
+int head[66000] = {0};
+unsigned short start = 0, terminal = 0;
+int time_limit = 0;
+int path[1000] = {0};
+int current_cheap = 2147483647;
+Edge edges_dij[1050000] = {0};
+bool included[66000] = {0};
+Point points[66000];
+
+int dfs(unsigned short cur, int cur_time, int cur_cost, int path_ptr) {
+    path[path_ptr] = cur;
+    if (cur_time > time_limit) {
+        return 0;
+    }
+
+    if (cur_cost > current_cheap) {
+        return 0;
+    }
+
+    if (cur == terminal) {
+        if (cur_cost < current_cheap) {
+            current_cheap = cur_cost;
+        }
+        return 0;
+    }
+
+    for (int i = head[cur]; i < head[cur + 1]; i++) {
+        for (int j = 0; j < path_ptr; j++) {
+            if (path[j] == edges[i][0]) {
+                continue;
+            }
+        }
+        dfs(edges[i][0], cur_time + edges[i][1], cur_cost + edges[i][2], path_ptr + 1);
+    }
+    return 0;
+}
+
+
+int dijkstra() {
+    std::priority_queue<Point, std::vector<Point>, compare_point<Point>> q;
+    for (int i = 0; i < N; i++) {
+        points[i] = Point{(unsigned short) i, 2147483647, 2147483647};
+        // q.push(points[i]);
+    }
+
+
+
+    // points[start].known_shortest = 0;
+    q.emplace(start, 0, 0);
+
+    while (!q.empty()) {
+        Point current = q.top();
+        q.pop();
+        if (current.name == terminal) {
+            printf("%d\n", current.known_shortest);
+            break;
+        }
+        for (int i = head[current.name]; i < head[current.name + 1]; i++) {
+            int new_time = current.time + edges_dij[i].time;
+            int new_cost = current.known_shortest + edges_dij[i].cost;
+            if (new_time > time_limit) {
+                continue;
+            }
+            if (new_cost < points[edges_dij[i].end].known_shortest) {
+                q.emplace(edges_dij[i].end, new_cost, new_time);
+                points[edges_dij[i].end].known_shortest = new_cost;
+                points[edges_dij[i].end].time = new_time < points[edges_dij[i].end].time ? new_time : points[edges_dij[i].end].time;
+            }
+            else if (new_time < points[edges_dij[i].end].time) {
+                q.emplace(edges_dij[i].end, new_cost, new_time);
+                points[edges_dij[i].end].time = new_time;
+            }
+        }
+    }
+
+}
+
+int main() {
+    scanf("%d %d", &N, &M);
+    if (N < 50000) {
+        head[0] = 0;
+        int next_empty_edge = 0;
+        int current_start = 0;
+        for (int i = 0; i < M; i++) {
+            int from, to, time, cost;
+            scanf("%d %d %d %d", &from, &to, &time, &cost);
+            if (from != current_start) {
+                for (int j = current_start + 1; j <= from; j++) {
+                    head[j] = next_empty_edge;
+                }
+                current_start = from;
+                // head[from] = next_empty_edge;
+            }
+            edges[next_empty_edge][0] = to;
+            edges[next_empty_edge][1] = time;
+            edges[next_empty_edge][2] = cost;
+            next_empty_edge++;
+        }
+        head[++current_start] = next_empty_edge;
+        scanf("%hu %hu %d", &start, &terminal, &time_limit);
+
+        dfs(start, 0, 0, 0);
+        if (current_cheap == 2147483647) {
+            printf("-1\n");
+            return 0;
+        }
+        printf("%d\n", current_cheap);
+        return 0;
+    }
+    else {
+        head[0] = 0;
+        int next_empty_edge = 0;
+        int current_start = 0;
+        for (int i = 0; i < M; i++) {
+            unsigned short from, to, time, cost;
+            scanf("%hu %hu %hu %hu", &from, &to, &time, &cost);
+            if (from != current_start) {
+                for (int j = current_start + 1; j <= from; j++) {
+                    head[j] = next_empty_edge;
+                }
+                current_start = from;
+                // head[from] = next_empty_edge;
+            }
+            // edges[next_empty_edge][0] = to;
+            // edges[next_empty_edge][1] = time;
+            // edges[next_empty_edge][2] = cost;
+            edges_dij[next_empty_edge] = Edge{to, time, cost};
+            next_empty_edge++;
+        }
+        head[++current_start] = next_empty_edge;
+        scanf("%hu %hu %d", &start, &terminal, &time_limit);
+
+        dijkstra();
+        return 0;
+    }
+}

2023210/input.txt

@@ -0,0 +1 @@
+3 3 1 1 2 1 2 3 10 3 4

2023210/main.cpp

@@ -0,0 +1,181 @@
+#include <stdio.h>
+
+struct CalcResult {
+    int dim_status;
+    int min_multiply_times;
+};
+
+unsigned short *tensors;
+// unsigned short tensors[66000];
+int n = 0, k = 0;
+CalcResult *m;
+// CalcResult m[10000];
+// int* m;
+int dim_sizes[32] = {0};
+
+// int precalc[2][1048576] = {0};
+
+inline int tensor_pos(int num, int dim) {
+    return k * num + dim;
+}
+
+inline int setm(int i, int j, int num) {
+    if (j <= i) {
+        return 0;
+    }
+
+    return m[i * n + j].min_multiply_times = num;
+}
+
+inline int getm(int i, int j) {
+    if (j <= i) {
+        return 0;
+    }
+
+    return m[i * n + j].min_multiply_times;
+}
+
+inline int setmdim(int i, int j, int d) {
+    if (j < i) {
+        return 0;
+    }
+
+    return m[i * n + j].dim_status = d;
+}
+
+inline int getmdim(int i, int j) {
+    if (j < i) {
+        return 0;
+    }
+
+    return m[i * n + j].dim_status;
+}
+
+int find_min(int start, int end) {
+    if (start == end || getm(start, end) != 0) {
+        return getm(start, end);
+    }
+
+    int min = 2147483647;
+    int needed_multiply_by_d = 1;
+    int dim_status = getmdim(start, end);
+
+    // prepare the dims
+    for (int i = 0; i < k - 2; i++) {
+        if ((dim_status >> i) & 1) {
+            needed_multiply_by_d *= dim_sizes[i];
+        }
+    }
+    // for (int i = 0; i <= (k - 2) / 16; i++) {
+    //     needed_multiply_by_d *= precalc[i][(dim_status >> (16 * i)) & 0xffff];
+    // }
+
+    for (int split_pos = start; split_pos < end; split_pos++) {
+        int total_needed = tensors[tensor_pos(start, k - 2)] *
+                           tensors[tensor_pos(split_pos, k - 1)] * tensors[tensor_pos(end, k - 1)] *
+                           needed_multiply_by_d;
+        int left = find_min(start, split_pos), right = find_min(split_pos + 1, end);
+        total_needed += left + right;
+        if (total_needed < min) {
+            min = total_needed;
+        }
+    }
+
+    setm(start, end, min);
+    return min;
+}
+
+int clac_min() {
+    for (int i = 0; i < n; i++) {
+        setm(i, i, 0);
+    }
+
+    for (int length = 1; length <= n; length++) {
+        for (int start = 0; start <= n - length; start++) {
+            int min = 2147483647;
+            int needed_multiply_by_d = 1;
+            int dim_status = getmdim(start, start + length);
+
+            // prepare the dims
+            for (int i = 0; i < k - 2; i++) {
+                if ((dim_status >> i) & 1) {
+                    needed_multiply_by_d *= dim_sizes[i];
+                }
+            }
+
+            int matrix_partial_needed = tensors[tensor_pos(start, k - 2)] *
+                                        tensors[tensor_pos(start + length, k - 1)] * needed_multiply_by_d;
+
+            for (int split = 0; split < length; split++) {
+                int total_needed = matrix_partial_needed * tensors[tensor_pos(start + split, k - 1)] + getm(start, start + split) + getm(start + split + 1, start + length);
+                if (total_needed < min) {
+                    min = total_needed;
+                }
+            }
+            setm(start, start + length, min);
+        }
+    }
+
+    return 0;
+}
+
+void preparedim(int length) {
+    if (length == 1) {
+        for (int i = 0; i < n; i++) {
+            int cur_stat = 0;
+            for (int j = 0; j < k - 2; j++) {
+                if (tensors[tensor_pos(i, j)] != 1) {
+                    cur_stat |= 1 << j;
+                }
+            }
+            setmdim(i, i, cur_stat);
+        }
+        return;
+    }
+
+    preparedim(length - 1);
+    for (int i = length - 1; i < n; i++) {
+        setmdim(i - length + 1, i, getmdim(i - length + 1, i - 1) | getmdim(i, i));
+    }
+}
+
+int main() {
+    scanf("%d %d", &n, &k);
+    tensors = new unsigned short[n * k];
+    // m = new CalcResult[(n + 1) * n / 2];
+    m = new CalcResult[n * n];
+
+    for (int i = 0; i < 32; i++) {
+        dim_sizes[i] = 1;
+    }
+    // m = new int[(n + 1) * n / 2];
+    for (int tensor_count = 0; tensor_count < n; tensor_count++) {
+        for (int dim = 0; dim < k; dim++) {
+            scanf("%hu", &tensors[tensor_pos(tensor_count, dim)]);
+            if (tensors[tensor_pos(tensor_count, dim)] != 1) {
+                dim_sizes[dim] = tensors[tensor_pos(tensor_count, dim)];
+            }
+        }
+    }
+
+    // for (int i = 0; i < 2; i++) {
+    //     for (int j = 0; j < 0xffff; j++) {
+    //         int prod = 1;
+    //         for (int r = 0; r < 16; r++) {
+    //             if ((j >> r) & 1) {
+    //                 prod *= dim_sizes[i * 16 + r];
+    //             }
+    //         }
+    //         precalc[i][j] = prod;
+    //     }
+    // }
+
+    preparedim(n);
+
+    // printf("%d\n", find_min(0, n - 1));
+
+    clac_min();
+    printf("%d\n", getm(0, n - 1));
+
+    return 0;
+}

csapp/csapp.h

@@ -0,0 +1,168 @@
+/* $begin csapp.h */
+#ifndef __CSAPP_H__
+#define __CSAPP_H__
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <ctype.h>
+#include <setjmp.h>
+#include <signal.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <errno.h>
+#include <math.h>
+#include <pthread.h>
+#include <semaphore.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+
+/* Default file permissions are DEF_MODE & ~DEF_UMASK */
+/* $begin createmasks */
+#define DEF_MODE   S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH
+#define DEF_UMASK  S_IWGRP|S_IWOTH
+/* $end createmasks */
+
+/* Simplifies calls to bind(), connect(), and accept() */
+/* $begin sockaddrdef */
+typedef struct sockaddr SA;
+/* $end sockaddrdef */
+
+/* Persistent state for the robust I/O (Rio) package */
+/* $begin rio_t */
+#define RIO_BUFSIZE 8192
+typedef struct {
+    int rio_fd;                /* Descriptor for this internal buf */
+    int rio_cnt;               /* Unread bytes in internal buf */
+    char *rio_bufptr;          /* Next unread byte in internal buf */
+    char rio_buf[RIO_BUFSIZE]; /* Internal buffer */
+} rio_t;
+/* $end rio_t */
+
+/* External variables */
+// extern int h_errno;    /* Defined by BIND for DNS errors */ 
+extern char **environ; /* Defined by libc */
+
+/* Misc constants */
+#define	MAXLINE	 8192  /* Max text line length */
+#define MAXBUF   8192  /* Max I/O buffer size */
+#define LISTENQ  1024  /* Second argument to listen() */
+
+/* Our own error-handling functions */
+void unix_error(char *msg);
+void posix_error(int code, char *msg);
+void dns_error(char *msg);
+void app_error(char *msg);
+
+/* Process control wrappers */
+pid_t Fork(void);
+void Execve(const char *filename, char *const argv[], char *const envp[]);
+pid_t Wait(int *status);
+pid_t Waitpid(pid_t pid, int *iptr, int options);
+void Kill(pid_t pid, int signum);
+unsigned int Sleep(unsigned int secs);
+void Pause(void);
+unsigned int Alarm(unsigned int seconds);
+void Setpgid(pid_t pid, pid_t pgid);
+pid_t Getpgrp();
+
+/* Signal wrappers */
+typedef void handler_t(int);
+handler_t *Signal(int signum, handler_t *handler);
+void Sigprocmask(int how, const sigset_t *set, sigset_t *oldset);
+void Sigemptyset(sigset_t *set);
+void Sigfillset(sigset_t *set);
+void Sigaddset(sigset_t *set, int signum);
+void Sigdelset(sigset_t *set, int signum);
+int Sigismember(const sigset_t *set, int signum);
+
+/* Unix I/O wrappers */
+int Open(const char *pathname, int flags, mode_t mode);
+ssize_t Read(int fd, void *buf, size_t count);
+ssize_t Write(int fd, const void *buf, size_t count);
+off_t Lseek(int fildes, off_t offset, int whence);
+void Close(int fd);
+int Select(int  n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, 
+	   struct timeval *timeout);
+int Dup2(int fd1, int fd2);
+void Stat(const char *filename, struct stat *buf);
+void Fstat(int fd, struct stat *buf) ;
+
+/* Memory mapping wrappers */
+void *Mmap(void *addr, size_t len, int prot, int flags, int fd, off_t offset);
+void Munmap(void *start, size_t length);
+
+/* Standard I/O wrappers */
+void Fclose(FILE *fp);
+FILE *Fdopen(int fd, const char *type);
+char *Fgets(char *ptr, int n, FILE *stream);
+FILE *Fopen(const char *filename, const char *mode);
+void Fputs(const char *ptr, FILE *stream);
+size_t Fread(void *ptr, size_t size, size_t nmemb, FILE *stream);
+void Fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);
+
+/* Dynamic storage allocation wrappers */
+void *Malloc(size_t size);
+void *Realloc(void *ptr, size_t size);
+void *Calloc(size_t nmemb, size_t size);
+void Free(void *ptr);
+
+/* Sockets interface wrappers */
+int Socket(int domain, int type, int protocol);
+void Setsockopt(int s, int level, int optname, const void *optval, int optlen);
+void Bind(int sockfd, struct sockaddr *my_addr, int addrlen);
+void Listen(int s, int backlog);
+int Accept(int s, struct sockaddr *addr, socklen_t *addrlen);
+void Connect(int sockfd, struct sockaddr *serv_addr, int addrlen);
+
+/* DNS wrappers */
+struct hostent *Gethostbyname(const char *name);
+struct hostent *Gethostbyaddr(const char *addr, int len, int type);
+
+/* Pthreads thread control wrappers */
+void Pthread_create(pthread_t *tidp, pthread_attr_t *attrp, 
+		    void * (*routine)(void *), void *argp);
+void Pthread_join(pthread_t tid, void **thread_return);
+void Pthread_cancel(pthread_t tid);
+void Pthread_detach(pthread_t tid);
+void Pthread_exit(void *retval);
+pthread_t Pthread_self(void);
+void Pthread_once(pthread_once_t *once_control, void (*init_function)());
+
+/* POSIX semaphore wrappers */
+void Sem_init(sem_t *sem, int pshared, unsigned int value);
+void P(sem_t *sem);
+void V(sem_t *sem);
+
+/* Rio (Robust I/O) package */
+ssize_t rio_readn(int fd, void *usrbuf, size_t n);
+ssize_t rio_writen(int fd, void *usrbuf, size_t n);
+void rio_readinitb(rio_t *rp, int fd); 
+ssize_t	rio_readnb(rio_t *rp, void *usrbuf, size_t n);
+ssize_t	rio_readlineb(rio_t *rp, void *usrbuf, size_t maxlen);
+
+/* Wrappers for Rio package */
+ssize_t Rio_readn(int fd, void *usrbuf, size_t n);
+void Rio_writen(int fd, void *usrbuf, size_t n);
+void Rio_readinitb(rio_t *rp, int fd); 
+ssize_t Rio_readnb(rio_t *rp, void *usrbuf, size_t n);
+ssize_t Rio_readlineb(rio_t *rp, void *usrbuf, size_t maxlen);
+
+/* Client/server helper functions */
+int open_clientfd(char *hostname, int portno);
+int open_listenfd(int portno);
+
+/* Wrappers for client/server helper functions */
+int Open_clientfd(char *hostname, int port);
+int Open_listenfd(int port); 
+
+#endif /* __CSAPP_H__ */
+/* $end csapp.h */

csapp/fork.c

@@ -0,0 +1,23 @@
+// #include <iostream>
+// #include <unistd.h>
+// #include <sys/wait.h>
+// #include <signal.h>
+// #include <stdio.h>
+// #include <stdlib.h>
+// #include <fcntl.h>
+
+#include "csapp.h"
+
+
+int main(int argc, char** argv) {
+    int fd1, fd2, fd3;
+    char *fname = argv[1];
+    fd1 = open(fname, O_CREAT | O_TRUNC | O_RDWR, S_IRUSR |S_IWUSR);
+    write(fd1, "pqrs", 4);
+    fd3 = open(fname, O_APPEND | O_WRONLY, 0);
+    write(fd3, "jklmn", 5);
+    fd2 = dup(fd1);
+    write(fd2, "wxyz", 4);
+    write(fd3, "ef", 2);
+    return 0;
+}

fork.cpp

@@ -0,0 +1,22 @@
+#include <iostream>
+#include <unistd.h>
+#include <sys/wait.h>
+
+int main() {
+    std::cout << "wo shi ni die" << std::endl;
+    pid_t pid;
+    int result;
+    for (int i = 0; i < 1024; i++) {
+        if ((pid = fork()) == 0) {
+            std::cout << "child #" << i << std::endl;
+            exit(i);
+            // return 0;
+        }
+        else {
+            waitpid(pid, &result, 0);
+        }
+        std::cout << "child #" << i << " exited with code" << WEXITSTATUS(result) << std::endl;
+    }
+
+    return 0;
+}

fuck.txt

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