feat: add solutions to lc problem: No.0386

No.0386.Lexicographical Numbers

Author: yanglbme

solution/0300-0399/0386.Lexicographical Numbers/README.md

@@ -38,7 +38,7 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-DFS。
+**方法一：DFS**
 
 <!-- tabs:start -->
 
@@ -49,18 +49,17 @@ DFS。
 ```python
 class Solution:
     def lexicalOrder(self, n: int) -> List[int]:
-        res = []
-
-        def dfs(i, n):
-            if i > n:
+        def dfs(u):
+            if u > n:
                 return
-            res.append(i)
-            for j in range(10):
-                dfs(i * 10 + j, n)
+            ans.append(u)
+            for i in range(10):
+                dfs(u * 10 + i)
 
+        ans = []
         for i in range(1, 10):
-            dfs(i, n)
-        return res
+            dfs(i)
+        return ans
 ```
 
 ### **Java**
@@ -70,21 +69,42 @@ class Solution:
 ```java
 class Solution {
     public List<Integer> lexicalOrder(int n) {
-        List<Integer> res = new ArrayList<>();
+        List<Integer> ans = new ArrayList<>();
         for (int i = 1; i < 10; ++i) {
-            dfs(res, i, n);
+            dfs(i, n, ans);
         }
-        return res;
+        return ans;
     }
 
-    private void dfs(List<Integer> res, int i, int n) {
-        if (i > n) {
+    private void dfs(int u, int n, List<Integer> ans) {
+        if (u > n) {
             return;
         }
-        res.add(i);
-        for (int j = 0; j < 10; ++j) {
-            dfs(res, i * 10 + j, n);
+        ans.add(u);
+        for (int i = 0; i < 10; ++i) {
+            dfs(u * 10 + i, n, ans);
+        }
+    }
+}
+```
+
+```java
+class Solution {
+    public List<Integer> lexicalOrder(int n) {
+        List<Integer> ans = new ArrayList<>();
+        int v = 1;
+        for (int i = 0; i < n; ++i) {
+            ans.add(v);
+            if (v * 10 <= n) {
+                v *= 10;
+            } else {
+                while (v % 10 == 9 || v + 1 > n) {
+                    v /= 10;
+                }
+                ++v;
+            }
         }
+        return ans;
     }
 }
 ```
@@ -95,22 +115,36 @@ class Solution {
 class Solution {
 public:
     vector<int> lexicalOrder(int n) {
-        vector<int> res;
-        for (int i = 1; i < 10; ++i)
-        {
-            dfs(res, i, n);
-        }
-        return res;
+        vector<int> ans;
+        for (int i = 1; i < 10; ++i) dfs(i, n, ans);
+        return ans;
     }
 
-    void dfs(vector<int> &res, int i, int n) {
-        if (i > n)
-            return;
-        res.push_back(i);
-        for (int j = 0; j < 10; ++j)
+    void dfs(int u, int n, vector<int>& ans) {
+        if (u > n) return;
+        ans.push_back(u);
+        for (int i = 0; i < 10; ++i) dfs(u * 10 + i, n, ans);
+    }
+};
+```
+
+```cpp
+class Solution {
+public:
+    vector<int> lexicalOrder(int n) {
+        vector<int> ans;
+        int v = 1;
+        for (int i = 0; i < n; ++i)
         {
-            dfs(res, i * 10 + j, n);
+            ans.push_back(v);
+            if (v * 10 <= n) v *= 10;
+            else
+            {
+                while (v % 10 == 9 || v + 1 > n) v /= 10;
+                ++v;
+            }
         }
+        return ans;
     }
 };
 ```
@@ -119,22 +153,40 @@ public:
 
 ```go
 func lexicalOrder(n int) []int {
-	var res []int
-	var dfs func(int, int)
-	dfs = func(i, n int) {
-		if i > n {
+	var ans []int
+	var dfs func(u int)
+	dfs = func(u int) {
+		if u > n {
 			return
 		}
-		res = append(res, i)
-		for j := 0; j < 10; j++ {
-			dfs(i*10+j, n)
+		ans = append(ans, u)
+		for i := 0; i < 10; i++ {
+			dfs(u*10 + i)
 		}
 	}
-
 	for i := 1; i < 10; i++ {
-		dfs(i, n)
+		dfs(i)
+	}
+	return ans
+}
+```
+
+```go
+func lexicalOrder(n int) []int {
+	var ans []int
+	v := 1
+	for i := 0; i < n; i++ {
+		ans = append(ans, v)
+		if v*10 <= n {
+			v *= 10
+		} else {
+			for v%10 == 9 || v+1 > n {
+				v /= 10
+			}
+			v++
+		}
 	}
-	return res
+	return ans
 }
 ```
 
@@ -162,6 +214,31 @@ impl Solution {
 }
 ```
 
+### **JavaScript**
+
+```js
+/**
+ * @param {number} n
+ * @return {number[]}
+ */
+var lexicalOrder = function (n) {
+    let ans = [];
+    function dfs(u) {
+        if (u > n) {
+            return;
+        }
+        ans.push(u);
+        for (let i = 0; i < 10; ++i) {
+            dfs(u * 10 + i);
+        }
+    }
+    for (let i = 1; i < 10; ++i) {
+        dfs(i);
+    }
+    return ans;
+};
+```
+
 ### **...**
 
 ```