Minimal Blog - @lekoarts/gatsby-theme-minimal-blog

为 Gatsby 搭建的博客加速

Mon, 09 Nov 2020 16:00:00 GMT

提高 Gatsby 博客性能

小插曲：

在 build 过程中，遇到了 sharp 出问题。重装了 xcode-select

Gatsby 和 GitHub Pages 提高博客性能新建一个 github repo，装你的东西

添加 prefix，把 public 的内容同步到 github
利用 postbuild，完成之后，把内容发布到 cdn，也就是我们的 github repo
netlify 改成 yarn build

publish to npm

what is the version?

push to github
Trigger Netlify build
In build script:

Determine a new version(need to be consistent because we want to use it as prefix)
build public folder
postbuild,
自动发布 npm 包

jsdeliver failed to fetch version

publish npm package from Netlify

git

为 Git 设置代理

Fri, 16 Oct 2020 16:00:00 GMT

最近开始刷 MIT 6.S081，git clone实在是龟速，上网查了为各个协议设置代理的方法，在此记录。

前提

请确认本地已经打开代理，切换到「全局模式」。找到监听的端口，比如我使用的客户端是 ClashX，可以点击Copy shell command来确认端口：

最简单的解决方案

使用 proxychains（现在新版本是叫proxychains-ng）一站式解决所有协议的配置。

http://

为防止 clone 国内仓库速度慢，我们只为 GitHub 设置代理：

取消设置：

ssh:// (git@)

这需要修改~/.ssh/config（如果没有则新建）。将以下代码加入config文件，填入你的ip和port：

git://

对于 GitHub ，可以利用insteadOf 来快速实现：

但是，对于 MIT 给出的仓库地址，git://g.csail.mit.edu/xv6-labs-2020，这个是行不通的。所以我们需要修改core.gitProxy。先写一个git-proxy的脚本，并把它放到PATH能找到的地方，再进行修改。

大功告成！

参考资料

两个有序数组的中位数

Thu, 14 May 2020 16:00:00 GMT

暴力解：merge两个array，取中位数，复杂度 $O(N)$ .

但这样的解法完全没有利用到这两个数组都是「有序」的这个信息。所以我们思考的时候，要考虑「有序」会给我们什么额外信息呢？

有序

这个中位数的特性就是，它一定能把array分成两部分，左边的都比它小，右边的都比它大。

A，B merge后的array, C, 的中位数，也能把这个array分成两部分。以下均假设C的长度是偶数（如果是奇数，一半的元素数量是floor(n/2) + 1，这一点在代码中有处理到）。如[1 2 3 4 5 6]，那么它的一半的长度为3。由于这个数组里的全部元素都来自A和B，前半段里肯定有n1来自A，n2来自B。

如果我们知道n1,n2，能不能找到C的中位数呢？

设一半的长度为k，我们需要找到(C[k-1] + C[k])/2。

因为A和B有序，第k个数是前半段最大的。An1-1和Bn2-1分别是A和B里这部分最大的一个，那么只要找出他俩的max，这个数一定是前半段最大。同理，第k+1个数肯定来自于An1和Bn2，他们要争夺「后半段最小」这个位置。

所以，如果知道n1和n2，我们就能求到C的中位数。

怎么求n1和n2

首先，k是已知的，k=(len(A)+len(B))//2。如果知道了n1，可以通过n2 = k - n1求到n2。所以最终的问题是：如何找到n1？

我们可以理解为，我们把A切了一刀，分成两部分。由于k是固定的，我们也能知道B在哪里被切了一刀

这一刀左边属于C的前半部分，所以必然有 $L_1\leq R_2, L_2 \leq R1$ 。所以，如果这一刀切的位置是正确的，这两个条件一定成立。如果不成立，我们便可以排除掉一些元素。

如何排除元素

$L_1 > R_2$

这种情况下，我们需要更小的L1，才有可能让它比R2小，那么这一刀得往左移，因为右边的都比L1大，绝对不可能小于R2。

$L_2 > R_1$

我们需要更大的R1，所以这一刀得往右移。

移动多少呢？

我们自然是可以一个一个地移，但要知道，我们的目的是「尽快」找到一个 $L_1$ ，从而使 $L_1> R_2$ 成立。这里要再次利用「有序」这个特点，引入binary search。

就好像猜数字那个例子，每一次我会告诉你，你的猜测是比我想的数大还是小，你自然可以一个一个地逼近我的答案。假设这个数在0到100之间，如果我想的是78，你猜的1，如果你按照1, 2, 3, …这个顺序来猜，再猜77次，可以猜对。但如果你用二分法，下一个你猜50，直接就排除掉了一半的元素。

这里也是一样，

我们可以确认新的L1来自区间[0, L1-1]，那么我们先猜这个区间的中位数，如果还是太大，那整个[mid, L1-1]区间都可以被排除掉。这样肯定比一次挪一个有效率。

边界情况

实现中，我们的cut为R，L为R-1。当cut为0时，cut-1是不存在的。

先思考，如果正确的cut在a0，那么C的前k个元素里，没有任何来自a。那意思就是，a0大于等于b0, b1 ... bk-1。由于 $b_{k-1}$ 是最大的一个，只需要确定 $a_0 \geq b_{k-1}$ 是否成立，即 $L2\leq R1$ 。在这个比较中，我们并不需要 $L_1 \leq R_2$ 。为了让边界一般化，不比较，等同于这个条件always true，这样对后来的比较不会造成任何影响。那么， $L_1 = \text{MIN\_INTEGER}$ 就能保证它小于等于任何R2。同理，当我们想无视 $L_2 \leq R1$ 时，只需要 $R_1 = \text{MAX\_INTEGER}$ 。

代码和几个细节

为什么一定要在短的那个里搜索？
我们需要保证k-cut1是一个非负数，因为最少也就是有零个元素来自某个数组。
$k = (n_1 + n_2) / 2$ 。但如果我们不选择短的那个，cut1就有可能大于k。那为什么短的那个不可能出现cut1 > k?
我们限制了 $cut_1 \leq n_1 \leq n_2$ , 如果 $cut_1 > k$ ，那么 $n_1 + n_2 \gt 2k$ 。如果C的长度是偶数，k正好是一半的元素，这个自相矛盾；如果是奇数，k为一半的元素加一，比一半的元素还多，2k更是超过了C的长度，矛盾。
cutR为什么可以是n1，不是超过数组长度了么？
首先要明确cutR代表了什么。cutL和cutR代表了这个cut可能出现的区间。如果cut在n1这个位置，证明A里面的全部元素都在前半段，也就是A的max小于B的min。这里我们在边界条件已经处理过了。
这里的elif可以是if么？能不能再多排除一点？
假设这两个条件同时成立， $L_1\gt R_2, L_2 \gt R_1$ ，那么 $R_1 \geq L_1 \gt R_2 \geq L_2 \Rightarrow R_1 \gt L_2$ 与 $L_2 \gt R_1$ 矛盾，所以是不可能的。

Longest Increasing Subsequence And Patience Game(Part2)

Sat, 04 Apr 2020 16:00:00 GMT

This part covers the actual implementation of the idea mentioned in Part1. I assume you’ve read it, and I’ll use claims proved in that part.

If you understand how the greedy algorithm works for Patience, the implementation is just simulationg the gameplay.

Goal

Remember, the algorithm puts the new card on the leftmost pile possible, and the length of the LIS is the total number of piles at the end of the game.

So the problem boils down to find out $\#\text{piles}$ .

Let’s play the game

1. Do we need to store every card in a pile?

When we’re looking for a valid pile, we only compare the new card $c$ and the top card $t$ of a pile. If $c \leq t$ , we put $c$ on the pile, and it becomes the new top card. So there’s no need to store every card.

2. How do we find the first valid pile?

Of course, we can look at every pile from left to right, that would be $O(n)$ , and the total complexity will be $O(n^2)$ . There’s an extra piece of information about those top cards: they form an increasing subsequence, i.e., they’re sorted.

How do we define “leftmost”? It is the first pile such that $\text{new card} \leq \text{top card}$ , so we have $\text{new card} \gt \text{top card of the last pile}$ .

If $\text{new card} \gt \text{some top card}$ , $\text{new card}$ is larger than anything to the left of that pile, so we can skip those elements. Yes, that’s binary search, the $logn$ part in $O(nlogn)$ .

Code

Line 6: right is len(piles) instead of the usual len(piles) - 1 because n can be larger than any top card in current piles, then it should be placed in a new pile.

Line 10-11: If piles[mid] < n, mid is definitely not the pile where n is placed, so we can exclude it.

Line 13: In this branch, n <= piles[mid], mid may be the pile we’re looking for, so we can’t exclude it. But we’re not sure if it’s the leftmost position, so we keep going.

Line 15-16: If the leftmost valid pile doesn’t exist yet, it means n is larger than all top cards, so we create a new pile for it, len(piles) will be incremented by 1 at the same time.

That’s all for this algorithm. Knowing why an algorithm works is always more important than memorizing the implementation. Proving its correctness is a very good way to learn.

Longest Increasing Subsequence And Patience Game(Part1)

Mon, 30 Mar 2020 16:00:00 GMT

This part focuses on the idea behind the solution. The actual implementation will be covered in Part2.

Problem

Given an unsorted array of integers, find the length of longest increasing subsequence. Example from LeetCode:

The $O(n^2)$ dynamic programming solution is quite straightforward. But I’m surprised to see the relationship between the card game Patience and LIS.

Picture from Princeton slides

Patience

Rules

You can only place a lowered-valued(or equal-valued) card on top of a higher-valued card, e.g., 2 on top of 3. Note Ace is NOT 1 here.
You can form a new pile and put your card onto it.

To understand why it’s related to LIS, we need to make two observations.

Observation1

For any legal strategy, $\#\text{piles}$ $\geq$ length of any increasing subsequence

Claim: Any increasing subsequence can use at most one card from each pile.

Proof

Assume we used $y$ and $y'$ from this pile. Since $y$ is on top of $y'$ , $y \le y’$ .

If $y = y’$ , they can’t form an increasing sequence. “increasing” is different from “non-decreasing”.

If $y \lt y’$ , the only way to use both cards in an increasing sequence is to place $y'$ after $y$ in that sequence. But $y$ is on top of $y'$ , so $y'$ comes before $y$ in the original array.

For example, [y', y] = [5, 2], 5 -> 2 is not an IS.

Thus, you can’t form an IS with more than one card from a pile $\Rightarrow$ length of any IS is at most $\#\text{piles}$ .

Greedy algorithm

Idea: put the new card on the leftmost pile possible, i.e., the first pile from left to right, such that $\text{new card} \le \text{top card of the pile}$ .

If we play the game with this strategy, we will notice that top cards form an IS(increasing sequence). For example,

2 4 7 8 Q is an IS.

Let’s prove this.

Observation2

Using the greedy strategy, top cards of piles increase from left to right at any time of the game

Proof

Assume $x \lt y$ , so we don’t have an IS. We have two cases:

$y$ comes before $x$
Then $x$ must be placed on top of $y$ by the algorithm. Contradiction.
$y$ comes after $x$
Since $x$ is put into the red pile, $x \gt y'$ or it’ll be in the blue pile by our greedy algorithm. $y$ is on top of $y'$ , so $y \le y'$ . But we assumed $x \lt y$ , so $x \lt y \le y'$ which contradicts $x\gt y'$ .

With these two observations, we can go head and prove the duality.

Duality

Lenght of LIS = #piles using the greedy strategy

Let the length of LIS be $L$ , and $P$ be the $\#\text{piles}$ created by the greedy algorithm. For an inequality, we have to show $“\geq”$ and $“\leq”$ directions.

$L \leq P$

This follows directly from $\#\text{piles}\geq$ length of nay IS in observation 1. LIS is an IS, so $L \leq P$ .

$L \geq P$

From observation 2, we know top cards of piles increase from left to right at any time of the game using this algorithm.

Note that the top cards are in general not an increasing subsequence — Berkeley notes

In this case, the top cards are 2 4 7 8 Q, but 4 comes after 7 in the original deck, so 4 -> 7 is not an IS.

To keep track of a valid IS, at the time of insertion of a card $c$ , we keep a pointer from $c$ to the current top card to the left of $c$ . For example, when 5 is inserted, 3 is the top card on its left, so there’s an arrow from 5 to 3.

Assume $P \gt L$ , let the top card on the $i\text{th}$ pile be $a_i$ . Since we have $P$ piles, we can follow the pointers starting at $a_p$ to get $a_1\leftarrow…\leftarrow a_{p-1} \leftarrow a_p$ . Note that from left to right, $a_1 \lt a_2 \lt \cdots \lt a_p$ . Thus, we get an IS of length $P$ .

But we claimed the length of the longest IS is $L$ . $P \gt L$ contraditcts that, so $P \leq L \ \square$

Reference

Longest Increasing Subsequence

Patience Sorting

Integer Partition With Distinct Parts

Sat, 18 Jan 2020 16:00:00 GMT

Question

How many ways can you write an integer n as the sum of a decreasing sequence(excluding n+0)?

Let’s look at an example from Wikipedia:

Alternatively, we could count partitions in which no number occurs more than once. Such a partition is called a partition with distinct parts. If we count the partitions of 8 with distinct parts, we also obtain 6:
8
7 + 1
6 + 2
5 + 3
5 + 2 + 1
4 + 3 + 1

The problem boils down to find the number of partition with distinct parts and simply subtract 1 from it. So I’ll focus on the core part.

Solution

Doing it by hand is easy. We choose the first element, e.g., 5, figure out 8-5=3, and try to split 3 into smaller parts. For human beings, checking “3 is less than 5” on paper happens in an instant. But we need a way to tell the computer what is the current max, so it knows possible choices for the next number.

Recursion

Visualize the result

Before we directly count the total number of sequences, it helps to visualize the result. Based on the idea from StackOverflow:

Translate partition(n, maxi) into English: Parition the number n into a decreasing sequence where the first element(largest one) is no bigger than maxi.

min(n-i, i-1) is to ensure the sequence is decreasing, and the max is no more than the number itself. To see that, let $M = min(n-i, i-1) \Rightarrow M \leq i-1 \text{ and } M \leq n-i$ .

This also avoids extra calculations because the size for each part can’t be more than what we have. For example, partition(5, 5) = partition(5, 14), so we don’t need to run the loop from 6 to 14.

Let’s count the total number

Base case is 0. When we have count_p(0, i-1), it means n=i or n=0, so the only possible partition is n = n no matter what the max is.

It works, but it’s super inefficient. To see where recalculations happen, I modified the function as below:

If these results are stored somewhere, we can avoid all recalculations and just use it.

Dynamic Programming

Let’s decipher the highlighted line:

p[i][j]: Partition the integer i into a decreasing sequence with the first element(largest one) less than or equal to j. Here we are accumulating the result. Say we want to partition 8. After selecting 5 as the first element, we want to find all decreasing sequences starting with 4 or less that sum to 8-5=3. As long as the first element is less than 5, the sequence is valid.

p[i][j-1] +: Accumulate the result as explained above.

p[i-j][min(i-j, j-1)]: Find all valid subsequences from i-j(what’s left). This corresponds to our recursion partitoin(n-i, min(n-i, i-1)).

Finally, we can find our result at p[n][n]: partition the integer n with the starting element less than or equal to n. This is exactly what we’re looking for.

If you want to exclude n=n+0, just return p[n][n]-1.

Here’s the table from P(8). The result is at p[8, 8] = 6 as we expected.

My favorite proofs from Analysis1

Wed, 18 Dec 2019 16:00:00 GMT

I’ve encountered a lot of proofs from MATH254, an introductory real analysis course. From my experience, most of the knowledge vanished the moment I walked out of the final exam room. But some proofs are just so elegant that forgetting them pains me.

This post is a collection of the neatest ones from my perspective. Besides reconstructing proofs, I also try to explain them in my own words to help you and my future self follow the line of thought.

Triangle inequality (In $\mathbb{R}^2$ )

Probably the most important inequality in this course.

$|x+y|\leq|x|+|y|$

Proof

First, we prove the claim: $|x|\leq a \iff -a\leq x\leq a$

\text{Here I only prove } ``\Rightarrow" \text{direction.}\\ \text{The other direction can be easily obtained by "opening" the absolute value.}\\ \begin{aligned} &\text{Case1. } x\geq 0 \\ &x = |x|\leq a, x\geq0 \Rightarrow a\geq0\Rightarrow -a \leq 0\leq x\\ \Rightarrow &-a \leq x \leq a\\ &\text{Case2. } x\lt 0 \\ & -x =|x|\leq a \Rightarrow x\geq-a\Rightarrow x<0\leq a\\ \Rightarrow &-a \leq x \leq a\\ \end{aligned}\\

For the triangle inequality:

\begin{aligned} |x|&\leq |x| \Rightarrow -|x| \leq x\leq|x|\\ |y|&\leq |y| \Rightarrow -|y| \leq y\leq|y|\\ -|x|-|y|&\leq x+y \leq|x|+|y|\\ \Rightarrow -(|x|+|y|)&\leq x+y \leq|x|+|y|\\ \Rightarrow |x+y| &\leq |x|+|y| \text{ by the claim above} \ \square \end{aligned}

Notes

The very obvious $|x|\leq|x|$ may be hard to come up with. When you have an equality, think about inequalities it may give you. The generalization for $\mathbb{R^n}$ can be proved by induction.

$\mathbb{Q}$ is dense in $\mathbb{R}$

That is, for any $x, y \in \mathbb{R}, x<y, \exists q \in \mathbb{Q}$ such that $x < q < y$ . Equivalently, there are infinite rational numbers between any two real numbers.

Proof

Let $n\in\mathbb{N},0<\frac{1}{n} < y-x \iff n>\frac{1}{y-x}$ by the Archimedean property.

Consider the set $S = \{ k \in \mathbb{N}: \frac{k}{n}\lt x \}$ . This set is finite, so its complement is infinite, non-empty especially. By the well-ordering principle, the set $\mathbb{R}\setminus S = \{k\in\mathbb{N}:\frac{k}{n}>x\}$ has a least element.

Let $m$ be the smallest natural number with $\frac{m}{n} > x$ , especially $\frac{m-1}{n}< x$ . $m, n \in \mathbb{N}, \frac{m}{n} \in \mathbb{Q}$ .

Claim: $x<\frac{m}{n}\leq y$ is the number we want.

\begin{aligned} &\frac{m}{n} =\frac{m-1}{n} + \frac{1}{n} < x+y-x =y\\ &\frac{m}{n} >x \text{ by our choice of m}\\ \Rightarrow &\ x<\frac{m}{n}<y \ \square \end{aligned}

Notes

The choice of $\frac{1}{n}<y-x$ in the first step seems mysterious, but everything follows that is easy to understand. The reason why we made this choice is: $\frac{1}{n}$ is the step size, if it’s greater than $y-x$ , assume $z<x, z+\frac{1}{n}$ may be greater than $y$ . That is, we may go past $y$ directly, which is bad for finding a number between $x, y$ .

Of course, the set $S =\{k\in\mathbb{N}:\frac{k}{n} \lt x\}$ may be empty ( $\frac{1}{n}\gt x$ ), but that doesn’t matter. $\mathbb{R}\setminus S$ is “more” infinite. The well-ordering principle holds as long as $\mathbb{R}\setminus S$ is non-empty. Using infinity to show non-emptiness may seem like an overkill, but interestingly, this kind of “overkill” happens all the time. It’s easier to get information from a stronger statement.

We require f to be continuous on the whole domain, but actually we only used continuity at a single point in this proof. — My analysis professor

Every continuous function on a compact domain is uniformly continuous.

Proof

Let $f: A→ \mathbb{R}$ be continuous. Let $\epsilon >0,$ then $\forall \ x\in \ A,\ \exists \delta _{x} >0:|x-u|< \delta _{x} \Longrightarrow \ |f( \ x) \ -f( \ u) |\ < \ \frac{1}{2} \epsilon$ (1)

Consider the neighborhoods $V_{\frac{1}{2} \delta _{x} }( x) ,\ \forall x\in A$ . Then, $C\ :=\{V_{\frac{1}{2} \delta _{x} }( x) :x\in A\}$ is an open cover of A since an arbitrary union of open sets are still open. A is compact, so $C$ has a finite subcover, $U:=\{V_{\frac{1}{2} \delta _{x_{k} }}( x_{1}) ,\ \cdots ,V_{\frac{1}{2} \delta _{x_{k} }}( x_{k})\}$ where $x_{1} ,\cdots ,x_{k} \in A$

Let $x,\ u\ \in A$ be arbitrary. We want to show $|x-u|< \delta \Longrightarrow |f( x) -f( u) |< \epsilon$ . For now, we only know $f$ behaves nicely locally(within each neighborhood around $x_{i} ,\ 1\leqslant i\leqslant k$ ), but uniformly continuity is a global property.

Intuition: If $x, u$ are in the same neighborhood around $x_{i}$ , we can utilize the nice, local behavior. The problem is that $\delta _{x_{i} }$ depends on $x_{i}$ , so the required distance varies in different locations on the domain. Can we find a $\delta$ that makes $x$ and $u$ “close enough” to be considered locally, no matter where they are?

Yes, we can. Why? Because $U$ is finite.

Let $\delta :=\min\left\{\frac{1}{2} \delta_{{x}_{1}},\cdots ,\frac{1}{2} \delta_{{x}_{k}}\right\}$ . $U$ covers A, so $x \in V_{\frac{1}{2} \delta_{{x}_{i}}}( x_{i})$ for some $x_{i} \in A$ .

\begin{gathered} \begin{aligned} |x-x_{i} | & < \frac{1}{2} \delta _{ {x}_{i} } < \delta _{ {x}_{i} } \Longrightarrow |f( x) -f( x_{i}) |< \frac{1}{2} \epsilon \ \text{by (1)}\\ |u-x_{i} | & =|u-x+x-x_{i} |\\ \text{triangle ineq} & \leq |u-x|+|x-x_{i} |< \delta +\frac{1}{2} \delta _{ {x}_{i} } \leq \frac{1}{2} \delta _{ {x}_{i} } +\frac{1}{2} \delta _{ {x}_{i} } =\delta _{ {x}_{i} }\\ |u-x_{i} |< \delta _{ {x}_{i} }& \Longrightarrow |f( u) -f( x_{i}) |< \frac{1}{2} \epsilon \\ |f( x) -f( u) | & =|f( x) -f( x_{i}) +f( x_{i}) -f( u) |\\ & \leq |f( x) -f( x_{i}) |+|f( x_{i}) -f( u) |\\ & < \frac{1}{2} \epsilon +\frac{1}{2} \epsilon =\epsilon \ \square \\ \end{aligned}\\ \end{gathered}

Notes

If $U$ is infinite, we are unable to take the minimum of all neighborhoods. To recap, our goal is to find a $\delta$ that is “close enough” for arbitrary $x,\ u\ \in A$ such that $|f( x) -f( u) |< \epsilon$ . The idea is to use $x_{i}$ as a bridge between $x$ and $u$ since we only know how $f$ behaves near each $x_{i}$ . Choosing $\frac{1}{2} \delta _{ {x}_{i} }$ neighborhoods ensures $x,\ u$ are in the same neighborhood of $x_{i}$ . This enables us to rely on $f$ ’s local behavior.

Bolzano-Weierstrass Theorem: Every bounded sequence in $\mathbb{R}$ has a convergent subsequence

The proof is only for $\mathbb{R}$ , but the theorem also holds in $\mathbb{R^n}$ and $\mathbb{C}^n$ .

Definition: Let $(x_n)$ be a sequence of real numbers. $x_N$ is called a peak if $\forall n\geq N, x_N\geq x_n$ i.e., $x_N$ is the largest term in the sequence starting from it.

Lemma: Every sequence of real numbers has a monotone subsequence

Proof

Let $(x_n)$ be a sequence of real numbers. There are two cases regrading the number of peaks:

Case1: $(x_n)$ has infinitely many peaks. We can find a subsequence $(x_{n_{k} })$ consisting of peaks. $(x_{n_{1} })$ is a peak, so $x_{n_{1} } \geq x_n, \forall n\geq n_1$ . Thus, $x_{n_{1} }\geq x_{n_{2} }$ . Similarly, $x_{n_{2} }$ is a peak, so $x_{n_{2} } \geq x_{n_{3} } \geq x_{n_{4} } \geq \cdots$ , etc.

The sequence is monotone increasing.

Case2: $(x_n)$ has finitely many peaks. Then, we choose our subsequence after the last peak. Let $x_N$ be the last peak. For $x_n, n\geq N, \exists x_m, m\gt n, \text{such that } \ x_m \gt x_n$ since $x_n$ is not a peak. Similarly, $x_m$ is not a peak, so $\exists x_k, k\gt m, \text{such that } \ x_k \gt x_m$ . Following this procedure, we end up with a monotone increasing subsequence.

In both cases, there exists a monotone subsequence in $(x_n)$ , so the lemma is proved.

Proof of the theorem

$(x_n)$ is bounded. By lemma, $(x_n)$ has a monotone subsequence $(x_{n_{k} })$ . By the monotone convergence theorem, the sequence converges $\square$ .

Notes

The proof is elegant and more importantly, easy to follow. The definition of peak is the key observation which makes the proof intuitive.

The power of a perfect definition. — The Teaching assistant

Countdown to 2020

Thu, 12 Dec 2019 16:00:00 GMT

Last year, I didn’t write down a list of TODOs for 2019 because I knew most of the wishes were just going to appear in New Year’s resolution for 2020 again. Copying and pasting are no fun. Frustration sucks. So I pondered for a few days and wrote one sentence before the clock went past eleven-fifty-nine: seize every chance.

Reading it out, hmm, I feel the excitement in it vaporized as a year went by. Also, it’s unclear what wishes I put into these three words. But hey, this is not a bad thing. Bullet points are so specific that they punch in my face with my failure ruthlessly. This line didn’t shatter my confidence instantly, so I got a chance to ask myself: did I seize every chance?

I didn’t. I missed chances to be happier and healthier. I could’ve left the not-so-urgent work for tomorrow, but I stayed up late because of the “I can complete it in 20 minutes” curse. I could’ve stretched more often, but I sat for too long for work I mentioned in the last sentence. I could’ve had much tastier Brussels sprouts, but I skipped the advice “don’t let them be watery” and poured balsamic vinegar into the baking pan.

And I could’ve written more. Memory fades, slowly but surely. Every piece of writing takes a snapshot of me the moment it was written. If my computer and cloud drives don’t fail me(please don’t), I’ll be able to see the older version of myself now and then. Once, I found my old diary between stacks of dusty books. My handwriting 5 years ago was awful. On the last page, I was surprised to see some comments from 3 years ago and 2 years ago. Then it becomes a routine for me to leave some comments or updates on this diary whenever I think of it. This happens rarely since I’m occupied by my ongoing life. But every time I hold that notebook, the feeling that time slips through my fingers is so real.

All old troubles seem trivial, and new troubles will become old eventually. This calms me down.

Number of submatrices that sum to target

Sat, 26 Oct 2019 16:00:00 GMT

This article is a complete analysis of 1074. Number of submatrices that sum to target from LeetCode.

Brute force

Consider every possible [a, b](top-left position) and [c, d] (bottom-right position) pair, and check their sums.

Time complexity

Without loss of generality, we assume the given matrix is a square matrix with size nxn.

For each a, we have n choices for b, and we have n choices for a —> $n^2$ .

For each [a, b], we have n*n pairs of [c, d]. —> $n^2 * n^2 = n^4$

However, each time we need to sum up all entries in the submatrix, giving us $O(n^6)$ . This is unacceptable for large inputs.

Optimize the brute force strategy

Do we need to sum up all entries in a submatrix every time? Can we reuse some computations?

Observation from a simple case: if the “height” of the matrix is 1, it is essentially an array. Let sum[i] denote the sum of the subarray from index 0 to i. If we want to know sum[3], we only need to add the third element to sum[2]. So we can store sum[i], and the addition only costs $O(1)$ .

We can extend the idea to 2D to reuse computations:

To get sum[i, j], we use the following loop:

Time complexity

Now, we can get the sum of any submatrix in $O(1)$ use the formula, but we still have $O(n^4)$ pairs of “top-left” and “bottom-right” which can’t be reduced further. The total cost is $O(n^4)$ .

“Compress” rows to 1D

Number of subarrays that sum to target

It’s always easier to start with a simpler version of the problem and extend the idea.

The 1D counterpart of this problem is “number of subarrays that sum to target”.

The idea is from the discussion of 560. Subarray Sum Equals K . It is amazing how a key observation reduced the cost to $O(n)$ .

Let sum[i, j] denote the sum from index i to j.

We observe that the any sum[i, j] can be broken into two parts:

\begin{aligned} \text{sum}[i, j] &= \text{sum}[0, j] - \text{sum}[i-1]\\ \text{Assume sum}[i, j]& = k, \text{the given target}\\ k &= \text{sum}[0, j] - \text{sum}[i-1]\\ \text{sum}[i-1] &=\text{sum}[0, j]-k \end{aligned}

The key observation is: #occurrences of sum[0, j]-k is equivalent to the number of subarrays that sum to k among all possible subarrays between 0 and j. Let’s consider an example:

From 1D to 2D

If we can control one dimension, we will reduce the matrix problem to the simpler array problem.

We first compute the prefix sum for each row, and we fix col i an col j to “convert” the submatrix to a subarray.

Time complexity

Get prefix sum for each row —> $O(n^2)$
For each pair of (i, j), we need $O(n)$ to determine the submatrices. There are $O(n^2)$ pairs —> $O(n^3)$

Total cost: $O(n^3)$

The similar idea of manipulating the equation can also be applied to any problem associated with “find the number of sub-patterns that satisfy a given condition”.

Ubuntu 18.04 Remap mouse buttons

Sun, 11 Aug 2019 16:00:00 GMT

Goals:

Write a script to remap mouse buttons
Run the script when the wireless mouse is connected

This is my mouse:

The default right-click is the bottom right button, but I would like to use the top right button instead.

Remap mouse buttons

First, xinput gives the id and name assigned to my mouse. Then, xinput list 18(device id) gives information about all buttons on my mouse.

However, the labels are quite confusing. To find out which button is pressed, run xinput test 18(device id) and press buttons you want to switch.

This is much clearer than the “Button Side”. To remap buttons, simply use xinput set-button-map $mouse_id 1 2 8 4 5 6 7 3 9 which switches 3 and 8.

Problem: When I restart the laptop, everything goes back to the default settings. With the help of StackOverflow, I created a script called remap_mouse_buttons.sh:

I added this to the Start Up Applications. Unfortunately, this didn’t work because if I didn’t connect the mouse when the computer started, the system wouldn’t find the device let alone remap buttons.

NOTE: I highly recommend you keep track of the error message by changing the second line to:

Additional resources:

Run the script when the mouse is connected

What I should do is executing the script when the mouse is connected via Bluetooth. udev rules are perfect for this job.

This tutorial on how to write basic udev rules helped me a lot.

Before writing rules, we need to gather information about the device. Run udevadm monitor and reconnect the device to get its path. Then, run udevadm info to get detailed information.

Now we have enough info to write the 88-remapmouse.rules:

== match the value

= assign a value (overwrite)

+= add another value

The script seems daunting, but what it says is simply “When the device with matching values is detected(connected), run /home/lisixian/remap_mouse.sh (the script in the first section)“.

NOTE: ENV{DISPLAY}=":0.0" and ENV{XAUTHORITY}="/run/user/1000/gdm/Xauthority are important. From the tutorial:

Those variables are essential when interacting with the X server programmatically, to setup some needed information: with the DISPLAY variable, we specify on what machine the server is running, what display and what screen we are referencing, and with XAUTHORITY we provide the path to the file which contains Xorg authentication and authorization information.

I got Cannot connect to X server error without these two lines.

Finally!

Now, disconnect your device and connect again to see the results.

Dot products and projections

Sat, 11 May 2019 16:00:00 GMT

Last year, I watched 3Blue1Brown’s video of dot products, but I only had a vague idea about their connection to projections. However, dot products showed up again and again in my math courses, so I decided to rewatch it. To my relief, it makes much more sense after MATH223, and the connection is indeed “truly awesome” as 3B1B said in the video. Now, I’m going to reconstruct the whole idea to deepen my understanding. I created images with the help of Mathcha, an online math editor.

Multiplying a $1\times 2$ matrix $\begin{bmatrix} u_{x} & u_{y} \end{bmatrix}$ with a 2D( $2\times 1$ ) vector $\begin{bmatrix} x\ y \end{bmatrix}$ gives us a $1\times 1$ scalar value $s\ =\ u_{x} x\ +u_{y} y.$ We interpret this as “transforming any 2D vector to a point on the 1D number line”. Although this numerical value is just from the familiar matrix-vector multiplication, its geometric meaning is exciting. Questions What does multiplying by $\begin{bmatrix} u_{x} & u_{y} \end{bmatrix}$ mean geometrically? How is this related to taking the dot product with the vector $\begin{bmatrix} u_{x}\ u_{y} \end{bmatrix}$ ?

Let $\vec{i} ,\ \vec{j}$ be unit vectors in $\mathbb{R}^{2}$ , and let $\vec{u} \ =\begin{bmatrix} u_{x}\ u_{y} \end{bmatrix}$ be a unit vector on line $L$ .

But $| \ proj_{\vec{i}} \ \vec{u} \ |$ is just the x-coordinate of $\vec{u} ,\ u_{x}$ . Now, if we want to know the orthogonal projection of any vector in $\mathbb{R}^{2}$ onto line $L$ , we only need to find where $\vec{i} \ ,\ \vec{j}$ land. Note: The projection outputs a scalar, the orange dot on the number line, not a 2D vector lying on the line. What we get is the component of a vector in the direction $\vec{u}$ . Define the transformation $T:\ \mathbb{R}^{2}\rightarrow \mathbb{R}$ as $\begin{aligned}T(\begin{bmatrix}x \\ y\end{bmatrix}) =\begin{bmatrix}u_{x} & u_{y}\end{bmatrix}\begin{bmatrix}x\\y\end{bmatrix}\end{aligned}$

which is the orthogonal projection onto line $L$ . First, is it linear? Let $\vec{v} ,\ \vec{w} \ \in \mathbb{R}^{2} , c\ \in \mathbb{R} .$ $\begin{aligned} T(\vec{0}) \ & =\ \begin{bmatrix} u_{x} & u_{y} \end{bmatrix}\begin{bmatrix} 0\\ 0 \end{bmatrix} \ =\ 0\\ & \\ T( c\vec{v} +\vec{w}) & =\ \begin{bmatrix} u_{x} & u_{y} \end{bmatrix}\begin{bmatrix} cv_{x} +w_{x}\\ cv_{y} +w_{y} \end{bmatrix}\\ & =\ u_{x}( cv_{x} +w_{x}) \ +\ u_{y}( cv_{y} +w_{y})\\ & =\ cv_{x} u_{x} \ +\ cv_{y} u_{y} +\ u_{x} w_{x} \ +u_{y} w_{y}\\ & \\ cT(\vec{v}) +T(\vec{w}) & =c\ \begin{bmatrix} u_{x} & u_{y} \end{bmatrix}\begin{bmatrix} v_{x}\\ v_{y} \end{bmatrix} \ +\ \begin{bmatrix} u_{x} & u_{y} \end{bmatrix}\begin{bmatrix} w_{x}\\ w_{y} \end{bmatrix}\\ & =\ c( u_{x} v_{x} +u_{y} v_{y}) \ +\ ( u_{x} w_{x} +u_{y} w_{y)} \end{aligned}$

It is easy to see that (1) = (2), so it is linear. For any vector $\begin{bmatrix} x\\y \end{bmatrix} \in \mathbb{R}^{2} ,$ $\begin{aligned}T\left(\begin{bmatrix}x\\y\end{bmatrix}\right) &=T\left( x\vec{i} \ +y\vec{j}\right) &=\ xT\left(\vec{i}\right) +yT\left(\vec{j}\right) &=\ xu_{x} \ +\ yu_{y}\end{aligned}$ which is the same as taking the dot product $\begin{bmatrix} x\ y \end{bmatrix} \cdot \begin{bmatrix} u_{x}\ u_{y} \end{bmatrix}$ . What if $\vec{u}$ is not the unit vector? Then the unit vector will be $\vec{u}\frac{1}{||\ \vec{u} \ ||}$ . So our matrix encoding the projection is now $\begin{bmatrix} \frac{u_{x}}{||\ \vec{u} \ ||} & \frac{u_{y}}{||\ \vec{u} \ ||} \end{bmatrix}$ . $\begin{aligned}T\left(\begin{bmatrix}x\\y\end{bmatrix}\right) \ & =\frac{xu_{x}}{||\ \vec{u} \ ||} \ +\ \frac{yu_{y}}{||\ \vec{u} \ ||}\\ ||\ \vec{u} \ ||\ T\left(\begin{bmatrix}x\\y\end{bmatrix}\right) \ & =xu_{x} \ +\ yu_{y}\end{aligned}\\$ The left hand is multiplying the projection of $\begin{bmatrix} x\ y \end{bmatrix}$ onto $L$ by the length of $\vec{u}$ , and the right hand side is $\begin{bmatrix} x\ y \end{bmatrix} \cdot \begin{bmatrix} u_{x}\ u_{y} \end{bmatrix}$

It is time to answer our questions:

Geometrically, multiplying by $\begin{bmatrix} u_{x} & u_{y} \end{bmatrix}$ is the same as finding the component of any vector in direction $\vec{u} \ =\begin{bmatrix} u_{x}\ u_{y} \end{bmatrix}$ and scaling by $| \vec{u} |$ . The lengthy version: projecting one vector onto the other one and multiplying by the length of the one being projected onto.
Applying this transformation gives us the same result as taking the dot product with $\vec{u}$ . This association is what he mentioned in the video as “duality”, a fascinating concept in math, so it’s definitely worth watching. Thanks again for the inspiration.

Minimum spanning tree

Sat, 06 Apr 2019 16:00:00 GMT

My attempt to reconstruct a detailed proof for a remark on Luc Devroye’s note of MST.

Max edge in a spanning tree

Let $T$ be a spanning tree of $G(V,E)$ and $L(T) = max_{(u,v)\in T}\ w[u, v]$ , the longest edge in a spanning tree.

$\text{Claim: The minimum spanning tree also minimizes L(T), that is, }$

L(MST) = min_{all\ T} L(T)

$\text{Proof:}$

” $\geq$ ”

MST $\in$ T, so L(MST) cannot be less than the minimum L(T) of all T’s.

” $\leq$ ”

In the figure above, we assume the red arrow is the longest edge in MST. We construct the MST by adding the shortest “bridge” each time we cross two sets, $A$ and $V-A$ . Thus, all other grey edges are longer than or equal to the red edge. These grey edges are in some other spanning trees.

For convenience, take one grey edge and call it $(x,y)$ because it’s from some vertex $x\in A$ to $y \in V-A$ . If it’s the max edge of its spanning tree, $T_x$ . $L(T_x) \geq L(MST)$ . If it’s not, there exists a max edge $(x',y')$ in $T_x$ such that $(x',y') \gt (x, y) \geq L(MST)$ . So $L(T_x) \geq L(MST)$ .

Q.E.D

Stream

Sun, 24 Mar 2019 16:00:00 GMT

Source code from COMP302 course page. Some helper functions are not shown here.

This post is my attempt to understand the beauty and power of streams.

Intro

The stream type below allows finite and infinite streams. Finite streams end with an end-of-stream marker that is written as Eos. An infinite stream does not end so it will not have an end-of-stream marker.

To represent “infinity”, we need to suspend the evaluation or no memory is large enough to hold infinite data. Here, we wrap the stream inside a function, and we “wake up” the stream by applying the function. We can never see the whole stream let alone print it, but we can ask for part of it, as long as this part is finite.

Examples

A stream of all ones

What is left after you take away the first 1 from infinitely many 1’s? Infinitely many 1’s!

So the code is saying: the stream starts with 1, and the rest of the stream also starts with 1, and the rest of the rest…

Natural numbers

Now we have 1,2,3,4,5…

Take out 1, we get an infinite stream starting from 2, then 3, then…

Fibonacci numbers

Below is a great picture that I found on stackoverflow for the famous one-liner in Haskell:

Partial sum

Binding & Closure

Tue, 22 Jan 2019 16:00:00 GMT

Binding & Closure

Binding created a (name, value) pair. Here, values can also be functions.

Declarations create bindings.

let: declaration
in: scope
NOTE: Do not confuse this with assignment.

3 components of closure

parameters
body
pointer to the environment when it is defined (static binding, lexical scoping)

NOTE: Environment can only be added, so there are layers. The pointer is pointing to the correct environment. A layer will be swept by garbage collection when there is no pointer points to it.

Side note: static binding and dynamic binding in Java:

Static binding
…So whenever a binding of static, private and final methods happen, type of the class is determined by the compiler at compile time (not determined by type of the object) and the binding happens then and there.
Dynamic binding
The type of the object is determined at the runtime(by the new someconstructor() keyword).
Overload and Override
The binding of overloaded methods is static and the binding of overridden methods is dynamic.

Binding vs. Assignment

In an imperative language, like Java, when we assign a value to a variable, we make an analogy between our variable and box. A variable itself is a container, and it holds some value. However, when we bind a name to a variable, we are attaching a label on that value.

Consider the code snippet below.

y = x + 1 is not closed on the name x. It is closed on the value 3 which was bound to x. So y will never change with x.

A really good explanation from stack overflow:

You can think of binding as a label on a suitcase, and assignment as a suitcase.

Now, let’s look at this example:

Layers

x | 99

f | (3 components) parameter: x | body: x | pointer to x = 3

x | 3

When we evaluate f x:

f is a closure, should be a function
Now its parameter is x! Let’s look for x
Ok, x is 99. Let’s evaluate. At this point, the layer x | 99 will go along with the pointer to the layer x | 3. IMPORTANT: 3 is masked because 99 is on the top layer.

When you evaluate this, x is not built-in. It is stored in a structure called environment. So the compiler will look for what is x.

x | 3 ---> base environment

x + 2 to be evaluated. x is found in the top layer.

Layers

x | 2

y | 4

x | 3

|||BASE ENV|||

NOTE: Never put bindings in the value part. It looks for x in the environment, and put the value of x in x+1.

Here, x-3 is masked, but it is still there. During the evaluation, it picks the x in the top layer.

Inductive Data Types

Sun, 20 Jan 2019 16:00:00 GMT

Lecture notes for COMP302.

Lists as inductive structures

NOTE: Induction works if and only if the system has a well-founded order.

Inductive definitions of data types

Let [ ] is a list. If you have a list, say l, and an item, sayi, then i::l is also a list. List0 = [ ] List1 = [1], [2],...,[ ] List2 = [1; 1], [1; 2],...,[4; 1],... The entire collection LIST = union_n LIST_n, an infinite set. However, the description is short, concise, and finite. This is a built-in type. There are functions like map, filter in this module.

How do I define my own inductive types?

Lists are linear data types, tail recursion works well for linear data types.

Trees

Trees are not built-in. Here we only talked about binary trees.

Inductive definition: EMPTY is a tree. If t1, t2 are trees, and i is an item. Then i(t1, t2) is a tree (NOT linear).
How to code a Tree in OCaml We have user-defined inductive types. type 'a tree = Empty | Node of 'a tree * 'a * 'a tree
1. 'a means:Polymorphic binary trees. 'a can be instantiated with any type: ints, strings…
  You don’t have to declare types. Type inference comes to help.
  let max (n, m) = if n < m then m else n;;
2. Node: constructor function. Always start with capital letters.
- Examples:
Expression trees
Const, Var, Plus, Times
type binding: char * int
type env = binding list
let rho: env = [('x', 11); ('y', 7); ('z', 2)]
What if there’s no such names?
- OPTION TYPE, a new type constructor. If t is a type, then t option is another type. Allows you to optionally return a NOne value.
- EX. 1729 is an integer.
  None is an integer option.
  Some 1729 is an integer option.
  Not returning int value, return int option.

fold_right and fold_left

Wed, 16 Jan 2019 16:00:00 GMT

credits: textbook from Cornell’s cs 3110.

Some useful explanations for fold functions in OCaml.

fold_right

Let’s start with two functions: sum and concat

We notice that these two functions are very similar. The only differences are the base case value (0 and "") and the operator (+ and ^).

We love excerptions. So we rewrite these two functions as

Why is it called fold_right?

Because the associativity is from right to left like this:

(a+(b+(c+0)))

fold_left

Similarly, the associativity, as its name suggests, is ((a+0)+b)+c). It is actually a handy function for tail recursion.

It is implemented like this:

fold_left op acc(base case) list

In fold_right, you will notice that the value passed as the initargument is the same for every recursive invocation of fold_right: it’s passed all the way down to where it’s needed, at the right-most element of the list, then used there exactly once. But in fold_left, you will notice that at each recursive invocation, the value passed as the argument acc can be different.

NOTE: In fold_left, its type is:

('a -> 'b -> 'a) -> 'a -> 'b list -> 'a = <fun> In the example rev below, the function is fun l a instead of fun a l

Minimal Blog - @lekoarts/gatsby-theme-minimal-blog

为 Gatsby 搭建的博客加速

为 Git 设置代理

前提

最简单的解决方案

http://

ssh:// (git@)

git://

参考资料

两个有序数组的中位数

有序

怎么求n1和n2

如何排除元素

边界情况

代码和几个细节

Longest Increasing Subsequence And Patience Game(Part2)

Goal

Let’s play the game

1. Do we need to store every card in a pile?

2. How do we find the first valid pile?

Code

Longest Increasing Subsequence And Patience Game(Part1)

Problem

Patience

Observation1

Proof

Greedy algorithm

Observation2

Proof

Duality

Lenght of LIS = #piles using the greedy strategy

Reference

Integer Partition With Distinct Parts

Question

Solution

Recursion

Visualize the result

Let’s count the total number

Dynamic Programming

My favorite proofs from Analysis1

Triangle inequality (In R2\mathbb{R}^2R2)

Proof

Notes

Q\mathbb{Q}Q is dense in R\mathbb{R}R

Proof

Notes

Every continuous function on a compact domain is uniformly continuous.

Proof

Notes

Bolzano-Weierstrass Theorem: Every bounded sequence in R\mathbb{R}R has a convergent subsequence

Lemma: Every sequence of real numbers has a monotone subsequence

Proof

Proof of the theorem

Notes

Countdown to 2020

Number of submatrices that sum to target

Brute force

Time complexity

Optimize the brute force strategy

Time complexity

“Compress” rows to 1D

Number of subarrays that sum to target

From 1D to 2D

Time complexity

Ubuntu 18.04 Remap mouse buttons

Goals:

Remap mouse buttons

Run the script when the mouse is connected

Dot products and projections

Minimum spanning tree

Max edge in a spanning tree

Stream

Intro

Examples

A stream of all ones

Natural numbers

Fibonacci numbers

Partial sum

Binding & Closure

Binding & Closure

Triangle inequality (In $\mathbb{R}^2$ )

$\mathbb{Q}$ is dense in $\mathbb{R}$

Bolzano-Weierstrass Theorem: Every bounded sequence in $\mathbb{R}$ has a convergent subsequence

Side note: static binding and dynamic binding in Java: