100!

.gitignore

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

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;
+}