update log

journals/2023_06_04.md

@@ -0,0 +1,2 @@
+- 小熊思想，我的评价是背了也没啥用，考试的时候一顿瞎扯
+	- 练习时长两年半的思政练习生正式毕业

journals/2023_06_05.md

@@ -0,0 +1,3 @@
+- 跑了好久的材料，姑且把pku-cs和thu-cs都搞完了
+- 新内存到了，32G真的好棒啊
+- 编译器是真的一点也写不下去啊，还特地把人喊过去就是为了告诉大家要快点写

journals/2023_06_06.md

@@ -0,0 +1,4 @@
+- 莫名其妙的有点焦虑，然后就又多整了两个学院的材料
+	- 然后全部寄出去了，花了我60，EMS这波属于是垄断抢钱
+- 编译器进展缓慢
+- 模式识别85，练习时长3个月的rk1到此结束

journals/2023_06_07.md

@@ -0,0 +1,6 @@
+- NJU-CS投递完成，SJTU还剩个表，这周填完
+	- 还有USTC-CS和计算所没填
+	- 28号考软件工程，有点尴尬
+- 姑且是强迫自己坐下来写编译器，争取这周跑通前后端，下周做优化
+	- 早知道考试去了，分高还省事
+- 大创结题了，基地正式毕业

journals/2023_06_09.md

@@ -0,0 +1,4 @@
+- 论语还是很棒的，写了一晚上给了97
+- 说起来，他们去CUHK面试的人结束了，今年居然有笔试，面试也在问笔试
+	- 就挺抽象的，属于是Regular的操作搬过来了？
+	- 感觉给需要去面试的人的名额也不是很多

journals/2023_06_10.md

@@ -0,0 +1,2 @@
+- 无聊的软工实验，不知道为啥有这门课
+- 玩群星，浪费时间捏

journals/2023_06_11.md

@@ -0,0 +1 @@
+- 玩群星，浪费时间捏

journals/2023_06_12.md

@@ -0,0 +1,4 @@
+- CU的老师26号来西安，顺手发了三篇论文让我看
+	- 然而是布线的论文，一脸懵逼
+- 提交了SJTU的申请表，姑且
+	- 因为和PKUCS冲突了，所以还是填了SE，到时候去和ipads对线

journals/2023_06_13.md

@@ -0,0 +1,3 @@
+- fdu入营，但是显然去不了，遂放弃offer
+- 编译器终于能从前端到后端全部跑通了啊啊啊
+- 太极拳考试，30分钟下课

journals/2023_06_14.md

@@ -0,0 +1,2 @@
+- 填了计算所的报名，虽然要推荐信，但是直接电子签了
+	- 甚至还要单独填问卷选老师，就挺抽象的

journals/2023_06_15.md

@@ -0,0 +1 @@
+- 继续在编译器上浪费时间

journals/2023_06_16.md

@@ -0,0 +1,2 @@
+- 要不是垃圾试点班，我编译原理就已经考完了啊啊啊
+- 难绷地写着常数传播

journals/2023_06_17.md

@@ -0,0 +1,4 @@
+- 软工实验，然后晚上写编译器
+- 姑且是把先进封装的introduction视频看完了
+- 早上去考了个游泳，意外的游泳馆还不错，三年来唯一一次去
+	- 没想到三年没游泳的我居然没被淹死

journals/2023_06_18.md

@@ -0,0 +1,2 @@
+- 写编译器，姑且写了个DCE，不想写了草
+- 提交了计算所的材料，和同学进行一个扎堆报考

journals/2023_06_19.md

@@ -0,0 +1,4 @@
+- 给编译器加了个简单的peephole优化，暂时先不写了，可能后面会再加个GVN和简单的循环分析吧
+- 填写了USTC-CS的报名
+- 姑且看完了第一篇论文
+	- 发现好像也没那么离谱

journals/2023_06_20.md

@@ -0,0 +1,4 @@
+- 10分钟的体育课，离谱
+- 看第二篇论文
+- 过了一个周末，为啥大家都有学上了，就我没有
+	- 寻思着是不是应该进行一个新的复习，毕竟还是要去夏令营的

journals/2023_06_21.md

@@ -0,0 +1 @@
+- 努力了一下，把论文看完了

journals/2023_06_22.md

@@ -0,0 +1 @@
+- 开始复习软工，看了一天ppt，好智障啊bbzl

journals/2023_06_23.md

@@ -0,0 +1,2 @@
+- 继续复习软工，又看了两章ppt
+- 联系了老师，26号下午面谈

journals/2023_06_24.md

@@ -0,0 +1 @@
+- 继续复习软工，把最抽象的测试看完了

journals/2023_06_25.md

@@ -0,0 +1,2 @@
+- 回头看了看之前的论文，还顺便看了两篇前置的论文
+	- 感觉算法啥的倒是不难，但是细节感觉还是挺多的

journals/2023_06_26.md

@@ -0,0 +1,5 @@
+- 最后一节软工课，有点离谱
+	- 果然抽象还是得看西工大啊，推迟两周开学把夏令营什么的直接橄榄了
+- 下午去南山苑面谈，结果发现根本不是面试，早在上个月他回我邮件的时候就已经相当于拿到offer了
+	- 草
+	- 太草了

journals/2023_06_27.md

@@ -0,0 +1 @@
+- 背了一天软工，睡觉做梦都是软工

journals/2023_06_28.md

@@ -0,0 +1,11 @@
+- 傻逼软工，我把116个问题全背下来了，结果考了问题集里面没有的东西
+	- 课上也没有个例题，纯纯的傻逼，也不知道题目怎么做
+- 跟学长吃了个饭，聊了下香港相关的东西
+	- 老师基本上没啥太大的问题，去也能去
+	- 会比较牛马就是了，居然要做七次TA，也不一定能按时毕业
+	- 香港会比较闷热，也不知道能不能顶得住
+- 姑且还是想认真准备一下PKU的夏令营，明天开始复习机试
+	- 只能说，大概是各有各的牛马之处吧
+	- 也有一部分原因是家长不想让我润掉，说什么要为国效力
+	- 又不得不再骂一次西工大，太傻逼了，推迟两周，复习个锤子
+	- 还要骂北大，机试不早说，只剩一周不到了啊啊啊

journals/2023_06_29.md

@@ -0,0 +1,9 @@
+- 看了一下2017年的机试，感觉裸考10题能写个4-5题的样子，复习一下能写个6题
+	- 大概3个模拟，1个搜索，1个最短路，1-2个dp，剩下的随缘
+	- 但是好像今年时间比较短，也不知道形式和难度会不会变
+	- 今年感觉300个人录取一半，有点小难绷
+- 究极难绷的事情出现了
+	- 今年填的老师居然大热门，要跟pku本科生抢，草，我去hk成了天意所指是吧，啊？
+		- 果然还是应该提前问一下的，草，不然就直接冲集成电路了
+	- 好傻逼啊，我居然还莫名其妙把rk2卡掉了，所以老师把我放进来玩是吧，听我说谢谢你，因为有你，大家都变成了小丑
+	- 算了继续复习去了，再骂一次傻逼西工大，把考试排这么靠后，一点缓冲都没有

journals/2023_06_30.md

@@ -0,0 +1,3 @@
+- dp的经典模型算是复习完了，不过如果是要自己想思路的dp，那显然是不会写的
+	- 开始看看图论
+- 摆烂，毁灭吧

journals/2023_07_01.md

@@ -0,0 +1,5 @@
+- PKU夏令营成为真正的小丑，北大爷自己还要抢名额三进二，我还是摆烂吧，去跟老师聊着玩玩
+	- 学长建议去联系一下其他的老师，然后得到回复说是没法换导师、只能等九月，我直接立马告辞
+	- 跑了三天材料，花费60r材料邮寄费用，最后换来旅游一趟，太tm小丑了，草
+		- 正式宣布，PKU成为我最讨厌的大学：材料究极麻烦、不包住不包路费、夏令营还不能调剂、一堆本科生跑过来抢名额。真nm傻逼啊
+- 忍住恶心写了点图论和二叉树的题。

logseq/config.edn

@@ -245,7 +245,7 @@
  :ref/linked-references-collapsed-threshold 50
 
  ;; Favorites to list on the left sidebar
- :favorites []
+ :favorites ["hls__Computer_Organization_and_Design_1681729306797_0" "hls__ostep_1680491762166_0" "hls__ostep_1681115599584_0"]
 
  ;; any number between 0 and 1 (the greater it is the faster the changes of the next-interval of card reviews) (default 0.5)
  ;; :srs/learning-fraction 0.5

pages/hls__Computer_Organization_and_Design_1681729306797_0.md

@@ -55,7 +55,6 @@ file-path:: ../../../../assets/Computer_Organization_and_Design_1681729306797_0.
   hl-page:: 47
   hl-color:: yellow
   id:: 643eb311-6b10-4fa3-9aa3-dfd5a59acf2c
-  collapsed:: true
 	- Semiconductor, silicon: add materials to silicon that allow tiny areas to transform into one of three devices: Excellent conductor, Excellent insulator and Transistor (conduct/insulate at some conditions)
 	  hl-page:: 48
 	  ls-type:: annotation
@@ -69,7 +68,6 @@ file-path:: ../../../../assets/Computer_Organization_and_Design_1681729306797_0.
   hl-page:: 51
   hl-color:: yellow
   id:: 643ec3be-027e-48b5-90e0-cd4a5e901691
-  collapsed:: true
 	- response/execution time: time between the start and completion of a task
 	  hl-page:: 52
 	  ls-type:: annotation

pages/hls__ostep_1681115599584_0.md

@@ -7,7 +7,6 @@ file-path:: ../assets/ostep_1681115599584_0.pdf
   hl-page:: 311
   hl-color:: yellow
   id:: 6433ca28-1bdf-433d-8ed9-0d54bf5ba940
-  collapsed:: true
 	- share the same address space and thus can access the same data
 	- context switch: the address space remains the same
 	  hl-page:: 311
@@ -25,7 +24,6 @@ file-path:: ../assets/ostep_1681115599584_0.pdf
 	  id:: 6433cba2-61bd-4549-a29f-2ad85b3e30cd
 	  hl-color:: yellow
 	- Why thread?
-	  collapsed:: true
 		- possible speedup through parallelization
 		- enable overlap of IO in a single program
 		- Though these could be done through multi-processing, threading makes share data easier

pages/动态规划.md

@@ -0,0 +1,118 @@
+- 考虑状态和转移两种东西
+	- 可以把状态看作是DAG上的点，然后状态转移就是边
+- LCS问题
+	- 两个序列`A[1..n]`和`B[1..m]`，求最长的子序列既是A的也是B的
+	- 状态的定义：$f(i,j)=A[1:i]和B[1:j]的LCS$
+	- 状态转移：如果`A[i]==B[j]`，那就直接接到后面`f[i,j] = f[i-1, j-1] + 1`；否则更新为`max(f[i-1, j], f[i, j-1])`
+- LIS问题
+	- 求最长子序列，子序列满足某些有序限制
+	- 状态为：以第i个元素结尾的子序列的最长
+	- 状态转移：在前面的子序列里面找一个最长且满足要求的子序列接在后面，也就是$f[i] = \max_{1 \le j \lt i, w[i] \lt w[j]}(f[j]) + 1$
+- 01背包
+	- n个物品，每个物品有价值v和重量w两种属性，W容量的包。每个物品是唯一的，求能装进包里的物品的价值最大。
+	- 状态：$f[i, c]$为前i个物品已经处理完成，容量为c情况下的最大价值
+	- 状态转移：当前物品装或者不装的决策。`f[i,c] = max(f[i-1, c], f[i-1, c-w[i]] + v[i])`。如果没有装物品，那么容量不变，价值也不变；如果装了第i个物品，那么它的价值增加且容量减小，因为这里当前状态`f[i,c]`是固定的（写的是一个逆推的形式），因此从更小容量转移过来
+	- 在具体做的时候，需要注意一下顺序和空间压缩。
+		- 因为第i个物品的i是有顺序的，因此可以压缩掉一维。变成这样`f[c] = max(f[c], f[c-w[i]] + v[i])`
+		- 在滚动压缩的时候，需要保证逆推的顺序，否则容量较小的情况更新过后会影响到后面的推导。不过在非滚动数组的情况下，这则是不需要的，因为反正用的是i-1的状态
+		  ```c
+		  for (int i = 1; i <= n; ++ i)
+		    for (int c = W; c >= w[i]; -- c)
+		      f[c] = max(f[c], f[c - w[i]] + v[i])
+		  ```
+- 完全背包
+	- n个物品，每个物品有价值v和重量w两种属性，W容量的包。**每个物品可以取多次**，求能装进包里的物品的价值最大。
+	- 状态是一样的，唯一的区别在于，完全背包需要枚举当前物品取的次数
+	- 不过这也可以优化掉，因为如果是正向推的话，已经包含了取所有可能次数的情况。
+	- **0-1背包和完全背包区别就在于容量维度的迭代顺序**
+	- ```c
+	  for (int i = 1; i <= n; ++ i)
+	    for (int c = w[i]; c <= W; ++ c)
+	      f[c] = max(f[c], f[c - w[i]] + v[i]);
+	  ```
+- 多重背包
+	- n种物品，每个物品有价值v和重量w两种属性，W容量的包。每种物品有k个，求能装进包里的物品的价值最大。
+	- 转化为01背包求解。因为每种物品k个就等于有k个属性相同的物品分别取或者不取。
+- 二维背包
+	- 这道题是很明显的 0-1 背包问题，可是不同的是选一个物品会消耗两种价值（经费、时间），只需在状态中增加一维存放第二种价值即可，同时枚举的时候也变成了两个量。
+	- 也就是状态方程变成了`f[i, c, d] = f[i-1, c - c[i], d-d[i]] + v[i]`
+- 背包状态数
+	- 把最大值换成求和，初始状态变成1（因为可以啥也不装）
+	- `f[i, c] += f[i-1, c-w[i]]`
+- 背包方案
+	- 一种方案是，另外开一个数组记录状态`[i, c]`下有没有取i
+	  ```
+	  int v = V;  // 记录当前的存储空间
+	  
+	  // 因为最后一件物品存储的是最终状态，所以从最后一件物品进行循环
+	  for (从最后一件循环至第一件) {
+	    if (g[i][v]) {
+	      选了第 i 项物品;
+	      v -= 第 i 项物品的重量;
+	    } else {
+	      未选第 i 项物品;
+	    }
+	  }
+	  ```
+	- 另一种方案则是，不优化空间，然后倒着推算更新点（如果状态和前一个物品不一样，那肯是发生了转移）
+	  ```
+	      for (int i = n; i > 0; -- i) {
+	          if (dp[i][res] != dp[i-1][res]) {
+	              sel[i] = 1;
+	              res -= w[i];
+	          }
+	      }
+	  ```
+- 区间dp
+	- 具有明显的可划分性质
+	- 经典的合并石子题：有n个数排成一个环，进行n-1次合并操作，每次操作将相邻的两堆合并成一堆，能获得新的一堆中的石子数量的和的得分。你需要最大化你的得分。
+	- 状态：`f[l, r]`表示区间`[l:r]`合并所能得到的最大分数
+	- 方程：枚举合并点k，取最大值。$f[l, r] = max_{i\le k \lt j}(f[i, k] + f[k+1, j]) + sum(a[i : j])$
+		- 可以用前缀和来优化求和的过程
+	- 这里的阶段划分并不是自然的（LIS、LCS自然就是LTR或者RTL，背包也就是依次取或者不取一个物品），需要用区间长度进行划分。
+		- 对于该问题，还需要解决围成环这个问题，比较好的解决方法是展开成链式之后复制一遍，最后在n个长度为n的区间里面取最大值
+	- 实现如下
+	  ```c
+	  for (int len = 1; len <= n; ++ len) {
+	    for (int i = 1; i + len - 1 <= 2 * n; ++ i) { // 实际上是j<=2*n
+	      int j = len + i - 1;
+	      for (int k = i; k < j; ++ k) {
+	        f[i][j] = max(f[i][j], f[i][k] + f[k+1][j] + sum[j] - sum[i-1]);
+	      }
+	    }
+	  }
+	  // ...
+	  ans = [&]() {
+	    int mx = 0;
+	    for (int i = 1; i <= n; ++ i) mx = max(mx, f[i][i + n - 1]);
+	    return mx;
+	  }();
+	  ```
+	- 能量项链也是完全一样的思路，除了值的计算方法稍有区别。
+- 树形dp
+	- 就是在树上做dp，一般而言，状态肯定有某一维是“以节点u为根的子树”这样的东西。然后遍历子树求解就好了。
+	- 例题1：POJ1463。有若干结点，结点之间有路相连，构成树形结构，如果在一个结点上放置一个士兵，与这个结点相连的路就可以被监视，现在要监视所有的路，问至少要多少士兵。
+		- 状态：$f[u, 0/1]$为节点u放置或者不放置士兵情况下的最小值
+		- 状态转移：如果当前节点不放，那么子节点就必须放置，也就是`f[u][0] = sum(f[v][1])`；如果当前节点放置，那么子节点可以放，也可以不放，对每个子节点的两种状态求最小值然后加起来（再加上自己1）：`f[u][1] = sum(min(f[v][0],f[v][1]) + 1`。
+	- 舞会那个题的思路也是类似的，就不赘述了
+- Floyd最短路
+	- 状态：$f[k, i, j]$表示只经过编号不超过k的节点，从i到j的最短路长度
+	- 状态转移：`f[k,i,j] = min(f[k-1, i, j], f[k-1, i, k] + f[k-1, k, j])`。决策就是要不要经过k这个点。
+		- 显然第一维可以推掉，所以实际上数组是两维度的
+	- 实现
+	  ```c
+	  int dis[maxn][maxn];
+	  memset(dis, 0x3f, sizeof(dis));
+	  for (int i = 1; i <= n; ++ i) dis[i][i] = 0;
+	  for (int i = 1; i <= m; ++ i) {
+	    int u = read(), v = read(), w = read();
+	    dis[u][v] = dis[v][u] = w;
+	  }
+	  for (int k = 1; k <= n; ++ k){
+	    for (int i = 1; i <= n; ++ i) {
+	      for (int j = 1; j <= n; ++ j){
+	        f[i][j] = min(f[i][j], f[i][k] + f[k][j]);
+	      }
+	    }
+	  }
+	  ```

pages/基础图论算法.md

@@ -0,0 +1,42 @@
+- 链星
+  ```c
+  inline void add_edge(int u, int v, int w) {
+    edge[cnt].next = head[u]; edge[cnt].v = v; edge[cnt].w = w; head[u] = cnt++;
+  }
+  ```
+- Dijkstra最短路
+	- 要求：边权非负（不仅仅是没有负环）
+	- 随手敲一个
+	  ```c
+	  priority_queue<node, vector<node>, greater<node>> pq;
+	  pq.push({s, 0});
+	  dis[s] = 0;
+	  while(!pq.empty()) {
+	    int u = pq.top().id;
+	    pq.pop();
+	    if (vis[u]) continue;
+	    vis[u] = true;
+	    for (int i = head[u]; i; i = edge[i].next) {
+	      int v = edge[i].to;
+	      if (dis[v] > dis[u] + edge[i].w) {
+	        dis[v] = dis[u] + edge[i].w;
+	        pq.push({v, dis[v]});
+	      }
+	    }
+	  }
+	  ```
+- Kruscal生成树
+	- ```c++
+	  std::sort(e + 1, e + e_cnt + 1);
+	  int ans = 0, t_cnt = 0;
+	  for (int i = 1; i <= n; ++ i) fa[i] = i;
+	  for (int i = 1; i <= e_cnt; ++ i) {
+	    int fau = findfa(e[i].u);
+	    int fav = findfa(e[i].v);
+	    if (fau != fav) {
+	      fa[fav] = fau; // attention! use fa[find(v)], not fa[v]
+	      ans += e[i].w;
+	      t_cnt ++;
+	    }
+	  }
+	  ```

pages/简单数学算法.md

@@ -0,0 +1,40 @@
+- 素数判定：$\sqrt{n}$算法，直接枚举所有小于根号n的数字，取模判定
+- 素数筛法：思路很简单，把所有素数的倍数标记为非素数即可。可能需要long long。
+- 质因数分解：一句话描述，从2开始到根号n，逮到一个因数就死命除掉
+  ```c
+  vector<int> prime_factor(int n){
+    vector<int> retval;
+    for (int i = 2; i * i <= n; ++ i){
+      if (n % i == 0) {
+        retval.push_back(i);
+        while(n % i == 0) n /= i;
+      }
+    }
+    if (n != 1) retval.push_back(i);
+  }
+  ```
+- 快速幂：
+  ```c
+  int fpow(int a, int b) { // a^b
+    int ans = 1;
+    while (b) {
+      if (b & 1) ans *= a;
+      a*= a;
+      b >>= 1;
+    }
+  }
+  ```
+- GCD辗转相除，没啥好说的，其实也可以用编译器函数
+  ```c
+  int gcd(int a, int b) {
+    return b == 0 ? a : gcd(b, a % b);
+  }
+  inline int gcd(int a, int b) {
+    while (b) {
+      int tmp = a;
+      a = b;
+      b = tmp % b;
+    }
+  }
+  ```
+	- 另外，对于 C++14，我们可以使用自带的 `__gcd(a,b)` 函数来求最大公约数。而对于 C++ 17，我们可以使用 [`<numeric>`](https://en.cppreference.com/w/cpp/header/numeric) 头中的 [`std::gcd`](https://en.cppreference.com/w/cpp/numeric/gcd) 与 [`std::lcm`](https://en.cppreference.com/w/cpp/numeric/lcm) 来求最大公约数和最小公倍数。