feat: add solutions to lc problems: No.1256,1259,1570 (doocs#1287)

* No.1256.Encode Number
* No.1259.Handshakes That Don't Cross
* No.1570.Dot Product of Two Sparse Vectors

Author: yanglbme

solution/1200-1299/1256.Encode Number/README.md

@@ -38,22 +38,71 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：位运算**
+
+我们将 $num$ 加一，然后将其转换为二进制字符串，去掉最高位的 $1$ 即可。
+
+时间复杂度 $O(\log n)$，空间复杂度 $O(\log n)$。其中 $n$ 为 $num$ 的大小。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def encode(self, num: int) -> str:
+        return bin(num + 1)[3:]
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public String encode(int num) {
+        return Integer.toBinaryString(num + 1).substring(1);
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    string encode(int num) {
+        bitset<32> bs(++num);
+        string ans = bs.to_string();
+        int i = 0;
+        while (ans[i] == '0') {
+            ++i;
+        }
+        return ans.substr(i + 1);
+    }
+};
+```
+
+### **Go**
+
+```go
+func encode(num int) string {
+	num++
+	s := strconv.FormatInt(int64(num), 2)
+	return s[1:]
+}
+```
+
+### **TypeScript**
 
+```ts
+function encode(num: number): string {
+    ++num;
+    let s = num.toString(2);
+    return s.slice(1);
+}
 ```
 
 ### **...**

solution/1200-1299/1256.Encode Number/README_EN.md

@@ -39,13 +39,56 @@
 ### **Python3**
 
 ```python
-
+class Solution:
+    def encode(self, num: int) -> str:
+        return bin(num + 1)[3:]
 ```
 
 ### **Java**
 
 ```java
+class Solution {
+    public String encode(int num) {
+        return Integer.toBinaryString(num + 1).substring(1);
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    string encode(int num) {
+        bitset<32> bs(++num);
+        string ans = bs.to_string();
+        int i = 0;
+        while (ans[i] == '0') {
+            ++i;
+        }
+        return ans.substr(i + 1);
+    }
+};
+```
+
+### **Go**
+
+```go
+func encode(num int) string {
+	num++
+	s := strconv.FormatInt(int64(num), 2)
+	return s[1:]
+}
+```
+
+### **TypeScript**
 
+```ts
+function encode(num: number): string {
+    ++num;
+    let s = num.toString(2);
+    return s.slice(1);
+}
 ```
 
 ### **...**

solution/1200-1299/1256.Encode Number/Solution.cpp

@@ -0,0 +1,12 @@
+class Solution {
+public:
+    string encode(int num) {
+        bitset<32> bs(++num);
+        string ans = bs.to_string();
+        int i = 0;
+        while (ans[i] == '0') {
+            ++i;
+        }
+        return ans.substr(i + 1);
+    }
+};

solution/1200-1299/1256.Encode Number/Solution.go

@@ -0,0 +1,5 @@
+func encode(num int) string {
+	num++
+	s := strconv.FormatInt(int64(num), 2)
+	return s[1:]
+}

solution/1200-1299/1256.Encode Number/Solution.java

@@ -0,0 +1,5 @@
+class Solution {
+    public String encode(int num) {
+        return Integer.toBinaryString(num + 1).substring(1);
+    }
+}

solution/1200-1299/1256.Encode Number/Solution.py

@@ -0,0 +1,3 @@
+class Solution:
+    def encode(self, num: int) -> str:
+        return bin(num + 1)[3:]

solution/1200-1299/1256.Encode Number/Solution.ts

@@ -0,0 +1,5 @@
+function encode(num: number): string {
+    ++num;
+    let s = num.toString(2);
+    return s.slice(1);
+}

solution/1200-1299/1259.Handshakes That Don't Cross/README.md

@@ -56,22 +56,146 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：记忆化搜索**
+
+我们设计一个函数 $dfs(i)$，表示 $i$ 个人的握手方案数。答案为 $dfs(n)$。
+
+函数 $dfs(i)$ 的执行逻辑如下：
+
+-   如果 $i \lt 2$，那么只有一种握手方案，即不握手，返回 $1$。
+-   否则，我们可以枚举第一个人与谁握手，记剩余的左边的人数为 $l$，右边的人数为 $r=i-l-2$，那么有 $dfs(i)= \sum_{l=0}^{i-1} dfs(l) \times dfs(r)$。
+
+为了避免重复计算，我们使用记忆化搜索的方法。
+
+时间复杂度 $O(n^2)$，空间复杂度 $O(n)$。其中 $n$ 为 $numPeople$ 的大小。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def numberOfWays(self, numPeople: int) -> int:
+        @cache
+        def dfs(i: int) -> int:
+            if i < 2:
+                return 1
+            ans = 0
+            for l in range(0, i, 2):
+                r = i - l - 2
+                ans += dfs(l) * dfs(r)
+                ans %= mod
+            return ans
+
+        mod = 10**9 + 7
+        return dfs(numPeople)
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    private int[] f;
+    private final int mod = (int) 1e9 + 7;
+
+    public int numberOfWays(int numPeople) {
+        f = new int[numPeople + 1];
+        return dfs(numPeople);
+    }
+
+    private int dfs(int i) {
+        if (i < 2) {
+            return 1;
+        }
+        if (f[i] != 0) {
+            return f[i];
+        }
+        for (int l = 0; l < i; l += 2) {
+            int r = i - l - 2;
+            f[i] = (int) ((f[i] + (1L * dfs(l) * dfs(r) % mod)) % mod);
+        }
+        return f[i];
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int numberOfWays(int numPeople) {
+        const int mod = 1e9 + 7;
+        int f[numPeople + 1];
+        memset(f, 0, sizeof(f));
+        function<int(int)> dfs = [&](int i) {
+            if (i < 2) {
+                return 1;
+            }
+            if (f[i]) {
+                return f[i];
+            }
+            for (int l = 0; l < i; l += 2) {
+                int r = i - l - 2;
+                f[i] = (f[i] + 1LL * dfs(l) * dfs(r) % mod) % mod;
+            }
+            return f[i];
+        };
+        return dfs(numPeople);
+    }
+};
+```
+
+### **Go**
+
+```go
+func numberOfWays(numPeople int) int {
+	const mod int = 1e9 + 7
+	f := make([]int, numPeople+1)
+	var dfs func(int) int
+	dfs = func(i int) int {
+		if i < 2 {
+			return 1
+		}
+		if f[i] != 0 {
+			return f[i]
+		}
+		for l := 0; l < i; l += 2 {
+			r := i - l - 2
+			f[i] = (f[i] + dfs(l)*dfs(r)) % mod
+		}
+		return f[i]
+	}
+	return dfs(numPeople)
+}
+```
 
+### **TypeScript**
+
+```ts
+function numberOfWays(numPeople: number): number {
+    const mod = 10 ** 9 + 7;
+    const f: number[] = Array(numPeople + 1).fill(0);
+    const dfs = (i: number): number => {
+        if (i < 2) {
+            return 1;
+        }
+        if (f[i] !== 0) {
+            return f[i];
+        }
+        for (let l = 0; l < i; l += 2) {
+            const r = i - l - 2;
+            f[i] += Number((BigInt(dfs(l)) * BigInt(dfs(r))) % BigInt(mod));
+            f[i] %= mod;
+        }
+        return f[i];
+    };
+    return dfs(numPeople);
+}
 ```
 
 ### **...**