feat: add solutions to lc problem: No.1259

No.1259.Handshakes That Don't Cross

Author: yanglbme

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

@@ -56,22 +56,115 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：动态规划**
+
+我们定义 $f[i]$ 表示 $i$ 个人的握手方案数，初始时 $f[0]=1$，答案为 $f[numPeople]$。
+
+考虑 $f[i]$，其中 $i \in [2,4,6,\cdots,numPeople]$，我们可以在顺时针方向上枚举第一个人跳过的人数 $j$，即第一个人跳过了 $j$ 个人去与另一个人握手，这里跳过的人数 $j$ 必须是偶数，所以 $j \in [0,2,4,\cdots,i-2]$，那么跳过的人的握手方案数为 $f[j]$，剩下的人数为 $k=i-j-2$，握手方案数为 $f[k]$，将这两部分相乘，再累加到 $f[i]$ 上即可，状态转移方程为：
+
+$$
+f[i] = \sum_{j=0}^{i-2} f[j] \times f[i-j-2]
+$$
+
+其中 $i \in [2,4,6,\cdots,numPeople]$，而 $j$ 为偶数，且 $j \in [0,2,4,\cdots,i-2]$。
+
+最后答案即为 $f[numPeople]$。
+
+时间复杂度 $O(n^2)$，空间复杂度 $O(n)$。其中 $n$ 为总人数。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def numberOfWays(self, numPeople: int) -> int:
+        mod = 10**9 + 7
+        f = [0] * (numPeople + 1)
+        f[0] = 1
+        for i in range(2, numPeople + 1, 2):
+            for j in range(0, i - 1, 2):
+                k = i - j - 2
+                f[i] = (f[i] + f[j] * f[k]) % mod
+        return f[numPeople]
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public int numberOfWays(int numPeople) {
+        final int mod = (int) 1e9 + 7;
+        long[] f = new long[numPeople + 1];
+        f[0] = 1;
+        for (int i = 2; i <= numPeople; i += 2) {
+            for (int j = 0; j < i - 1; j += 2) {
+                int k = i - j - 2;
+                f[i] = (f[i] + f[j] * f[k]) % mod;
+            }
+        }
+        return (int) f[numPeople];
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int numberOfWays(int numPeople) {
+        const int mod = 1e9 + 7;
+        long long f[numPeople + 1];
+        memset(f, 0, sizeof(f));
+        f[0] = 1;
+        for (int i = 2; i <= numPeople; i += 2) {
+            for (int j = 0; j < i - 1; j += 2) {
+                int k = i - j - 2;
+                f[i] = (f[i] + f[j] * f[k]) % mod;
+            }
+        }
+        return f[numPeople];
+    }
+};
+```
+
+### **Go**
+
+```go
+func numberOfWays(numPeople int) int {
+	const mod int = 1e9 + 7
+	f := make([]int, numPeople+1)
+	f[0] = 1
+	for i := 2; i <= numPeople; i += 2 {
+		for j := 0; j < i-1; j += 2 {
+			k := i - j - 2
+			f[i] = (f[i] + f[j]*f[k]) % mod
+		}
+	}
+	return f[numPeople]
+}
+```
 
+### **TypeScript**
+
+```ts
+function numberOfWays(numPeople: number): number {
+    const mod = BigInt(10 ** 9 + 7);
+    const f: bigint[] = new Array(numPeople + 1).fill(0n);
+    f[0] = 1n;
+    for (let i = 2; i <= numPeople; i += 2) {
+        for (let j = 0; j < i - 1; j += 2) {
+            const k = i - j - 2;
+            f[i] = (f[i] + f[j] * f[k]) % mod;
+        }
+    }
+    return Number(f[numPeople]);
+}
 ```
 
 ### **...**

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

@@ -36,18 +36,111 @@
 
 ## Solutions
 
+**Solution 1: Dynamic Programming**
+
+We define $f[i]$ as the number of handshake schemes for $i$ people, and $f[0]=1$ at the beginning, the answer is $f[numPeople]$.
+
+Considering $f[i]$, where $i \in [2,4,6,\cdots,numPeople]$, we can enumerate the number of people skipped by the first person in the clockwise direction, that is, the first person skipped $j$ people to shake hands with another person, where the number of people skipped $j$ must be even, so $j \in [0,2,4,\cdots,i-2]$, then the handshake scheme of the skipped people is $f[j]$, and the remaining number of people is $k=i-j-2$, the handshake scheme is $f[k]$, multiply these two parts and add them to $f[i]$, the state transition equation is:
+
+$$
+f[i] = \sum_{j=0}^{i-2} f[j] \times f[i-j-2]
+$$
+
+where $i \in [2,4,6,\cdots,numPeople]$, and $j$ is even, and $j \in [0,2,4,\cdots,i-2]$.
+
+Finally, the answer is $f[numPeople]$.
+
+The time complexity is $O(n^2)$, and the space complexity is $O(n)$. Where $n$ is the total number of people.
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 ```python
-
+class Solution:
+    def numberOfWays(self, numPeople: int) -> int:
+        mod = 10**9 + 7
+        f = [0] * (numPeople + 1)
+        f[0] = 1
+        for i in range(2, numPeople + 1, 2):
+            for j in range(0, i - 1, 2):
+                k = i - j - 2
+                f[i] = (f[i] + f[j] * f[k]) % mod
+        return f[numPeople]
 ```
 
 ### **Java**
 
 ```java
+class Solution {
+    public int numberOfWays(int numPeople) {
+        final int mod = (int) 1e9 + 7;
+        long[] f = new long[numPeople + 1];
+        f[0] = 1;
+        for (int i = 2; i <= numPeople; i += 2) {
+            for (int j = 0; j < i - 1; j += 2) {
+                int k = i - j - 2;
+                f[i] = (f[i] + f[j] * f[k]) % mod;
+            }
+        }
+        return (int) f[numPeople];
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int numberOfWays(int numPeople) {
+        const int mod = 1e9 + 7;
+        long long f[numPeople + 1];
+        memset(f, 0, sizeof(f));
+        f[0] = 1;
+        for (int i = 2; i <= numPeople; i += 2) {
+            for (int j = 0; j < i - 1; j += 2) {
+                int k = i - j - 2;
+                f[i] = (f[i] + f[j] * f[k]) % mod;
+            }
+        }
+        return f[numPeople];
+    }
+};
+```
+
+### **Go**
+
+```go
+func numberOfWays(numPeople int) int {
+	const mod int = 1e9 + 7
+	f := make([]int, numPeople+1)
+	f[0] = 1
+	for i := 2; i <= numPeople; i += 2 {
+		for j := 0; j < i-1; j += 2 {
+			k := i - j - 2
+			f[i] = (f[i] + f[j]*f[k]) % mod
+		}
+	}
+	return f[numPeople]
+}
+```
 
+### **TypeScript**
+
+```ts
+function numberOfWays(numPeople: number): number {
+    const mod = BigInt(10 ** 9 + 7);
+    const f: bigint[] = new Array(numPeople + 1).fill(0n);
+    f[0] = 1n;
+    for (let i = 2; i <= numPeople; i += 2) {
+        for (let j = 0; j < i - 1; j += 2) {
+            const k = i - j - 2;
+            f[i] = (f[i] + f[j] * f[k]) % mod;
+        }
+    }
+    return Number(f[numPeople]);
+}
 ```
 
 ### **...**

solution/1200-1299/1259.Handshakes That Don't Cross/Solution.cpp

@@ -0,0 +1,16 @@
+class Solution {
+public:
+    int numberOfWays(int numPeople) {
+        const int mod = 1e9 + 7;
+        long long f[numPeople + 1];
+        memset(f, 0, sizeof(f));
+        f[0] = 1;
+        for (int i = 2; i <= numPeople; i += 2) {
+            for (int j = 0; j < i - 1; j += 2) {
+                int k = i - j - 2;
+                f[i] = (f[i] + f[j] * f[k]) % mod;
+            }
+        }
+        return f[numPeople];
+    }
+};

solution/1200-1299/1259.Handshakes That Don't Cross/Solution.go

@@ -0,0 +1,12 @@
+func numberOfWays(numPeople int) int {
+	const mod int = 1e9 + 7
+	f := make([]int, numPeople+1)
+	f[0] = 1
+	for i := 2; i <= numPeople; i += 2 {
+		for j := 0; j < i-1; j += 2 {
+			k := i - j - 2
+			f[i] = (f[i] + f[j]*f[k]) % mod
+		}
+	}
+	return f[numPeople]
+}

solution/1200-1299/1259.Handshakes That Don't Cross/Solution.java

@@ -0,0 +1,14 @@
+class Solution {
+    public int numberOfWays(int numPeople) {
+        final int mod = (int) 1e9 + 7;
+        long[] f = new long[numPeople + 1];
+        f[0] = 1;
+        for (int i = 2; i <= numPeople; i += 2) {
+            for (int j = 0; j < i - 1; j += 2) {
+                int k = i - j - 2;
+                f[i] = (f[i] + f[j] * f[k]) % mod;
+            }
+        }
+        return (int) f[numPeople];
+    }
+}

solution/1200-1299/1259.Handshakes That Don't Cross/Solution.py

@@ -0,0 +1,10 @@
+class Solution:
+    def numberOfWays(self, numPeople: int) -> int:
+        mod = 10**9 + 7
+        f = [0] * (numPeople + 1)
+        f[0] = 1
+        for i in range(2, numPeople + 1, 2):
+            for j in range(0, i - 1, 2):
+                k = i - j - 2
+                f[i] = (f[i] + f[j] * f[k]) % mod
+        return f[numPeople]

solution/1200-1299/1259.Handshakes That Don't Cross/Solution.ts

@@ -0,0 +1,12 @@
+function numberOfWays(numPeople: number): number {
+    const mod = BigInt(10 ** 9 + 7);
+    const f: bigint[] = new Array(numPeople + 1).fill(0n);
+    f[0] = 1n;
+    for (let i = 2; i <= numPeople; i += 2) {
+        for (let j = 0; j < i - 1; j += 2) {
+            const k = i - j - 2;
+            f[i] = (f[i] + f[j] * f[k]) % mod;
+        }
+    }
+    return Number(f[numPeople]);
+}