feat: add solutions to lc problem: No.3955 (#5245)

Author: yanglbme

solution/3900-3999/3955.Valid Binary Strings With Cost Limit/README.md

@@ -82,32 +82,200 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3900-3999/3955.Va
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：DFS
+
+我们希望生成长度为 $n$ 的二进制字符串，并满足：
+
+- 每个 `1` 的位置 $i$（从 $0$ 开始）累加的总和不超过 $k$，即
+
+
+$$
+\sum_{i \mid s_i = 1} i \le k
+$$
+
+- 任意连续的 `1` 不能直接相邻。
+
+因此，我们设计一个递归函数 $\text{dfs}(i, tot)$，表示：
+
+- 当前处理到字符串的第 $i$ 个位置；
+- 当前已经放置的所有 `1` 的下标之和为 $tot$。
+
+#### 递归逻辑
+
+**1. 递归终止条件**
+
+当 $i \ge n$ 时，说明长度为 $n$ 的字符串已经构造完成，将当前路径加入答案。
+
+**2. 选择 `0`**
+
+当前位置始终可以放置 `0`，递归调用 $\text{dfs}(i + 1, tot)$，由于当前位置放置的是 `0`，因此总和不发生变化。
+
+**3. 选择 `1`**
+
+只有同时满足以下两个条件时，当前位置才能放置 `1`：前一个字符不存在或为 `0` 并且 $tot + i \le k$。此时递归调用 $\text{dfs}(i + 1, tot + i)$。
+
+**4. 回溯**
+
+每次递归返回后，撤销当前选择，恢复到进入递归前的状态，从而继续搜索其他可能的方案。
+
+时间复杂度 $O(n \times 2^n)$，空间复杂度 $O(n)$。
 
 <!-- tabs:start -->
 
 #### Python3
 
 ```python
-
+class Solution:
+    def generateValidStrings(self, n: int, k: int) -> list[str]:
+        def dfs(i: int, tot: int):
+            if i >= n:
+                ans.append("".join(path))
+                return
+            path.append("0")
+            dfs(i + 1, tot)
+            path.pop()
+            if (not path or path[-1] == "0") and tot + i <= k:
+                path.append("1")
+                dfs(i + 1, tot + i)
+                path.pop()
+
+        ans = []
+        path = []
+        dfs(0, 0)
+        return ans
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    private int n;
+    private int k;
+    private List<String> ans;
+    private StringBuilder path;
+
+    public List<String> generateValidStrings(int n, int k) {
+        this.n = n;
+        this.k = k;
+        ans = new ArrayList<>();
+        path = new StringBuilder();
+
+        dfs(0, 0);
+
+        return ans;
+    }
+
+    private void dfs(int i, int tot) {
+        if (i >= n) {
+            ans.add(path.toString());
+            return;
+        }
+
+        path.append('0');
+        dfs(i + 1, tot);
+        path.deleteCharAt(path.length() - 1);
+
+        if ((path.isEmpty() || path.charAt(path.length() - 1) == '0') && tot + i <= k) {
+            path.append('1');
+            dfs(i + 1, tot + i);
+            path.deleteCharAt(path.length() - 1);
+        }
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    vector<string> generateValidStrings(int n, int k) {
+        vector<string> ans;
+        string path;
+
+        auto dfs = [&](this auto&& dfs, int i, int tot) -> void {
+            if (i >= n) {
+                ans.push_back(path);
+                return;
+            }
+
+            path.push_back('0');
+            dfs(i + 1, tot);
+            path.pop_back();
+
+            if ((path.empty() || path.back() == '0') && tot + i <= k) {
+                path.push_back('1');
+                dfs(i + 1, tot + i);
+                path.pop_back();
+            }
+        };
+
+        dfs(0, 0);
+
+        return ans;
+    }
+};
 ```
 
 #### Go
 
 ```go
+func generateValidStrings(n int, k int) []string {
+	ans := []string{}
+	path := make([]byte, 0, n)
+
+	var dfs func(int, int)
+	dfs = func(i, tot int) {
+		if i >= n {
+			ans = append(ans, string(path))
+			return
+		}
+
+		path = append(path, '0')
+		dfs(i+1, tot)
+		path = path[:len(path)-1]
+
+		if (len(path) == 0 || path[len(path)-1] == '0') && tot+i <= k {
+			path = append(path, '1')
+			dfs(i+1, tot+i)
+			path = path[:len(path)-1]
+		}
+	}
+
+	dfs(0, 0)
+
+	return ans
+}
+```
+
+#### TypeScript
+
+```ts
+function generateValidStrings(n: number, k: number): string[] {
+    const ans: string[] = [];
+    const path: string[] = [];
+
+    const dfs = (i: number, tot: number): void => {
+        if (i >= n) {
+            ans.push(path.join(''));
+            return;
+        }
+
+        path.push('0');
+        dfs(i + 1, tot);
+        path.pop();
+
+        if ((path.length === 0 || path[path.length - 1] === '0') && tot + i <= k) {
+            path.push('1');
+            dfs(i + 1, tot + i);
+            path.pop();
+        }
+    };
+
+    dfs(0, 0);
 
+    return ans;
+}
 ```
 
 <!-- tabs:end -->