feat: add solutions to lc problem: NO.0406

No.0406.Queue Reconstruction by Height

Author: yanglbme

solution/0400-0499/0406.Queue Reconstruction by Height/README.md

@@ -48,27 +48,77 @@
 	<li>题目数据确保队列可以被重建</li>
 </ul>
 
-
 ## 解法
 
 <!-- 这里可写通用的实现逻辑 -->
 
+对 people 按照身高降序排列，若身高相同，则按照人数 k 升序排列。然后按照索引位置依次将 people 插入到结果列表中即可。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def reconstructQueue(self, people: List[List[int]]) -> List[List[int]]:
+        people.sort(key=lambda x: (-x[0], x[1]))
+        ans = []
+        for p in people:
+            ans.insert(p[1], p)
+        return ans
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public int[][] reconstructQueue(int[][] people) {
+        Arrays.sort(people, (a, b) -> a[0] == b[0] ? a[1] - b[1] : b[0] - a[0]);
+        List<int[]> ans = new ArrayList<>(people.length);
+        for (int[] p : people) {
+            ans.add(p[1], p);
+        }
+        return ans.toArray(new int[ans.size()][]);
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {
+        sort(people.begin(), people.end(), [](const vector<int>& a, const vector<int>& b) {
+            return a[0] > b[0] || (a[0] == b[0] && a[1] < b[1]);
+        });
+        vector<vector<int>> ans;
+        for (const vector<int>& p: people)
+            ans.insert(ans.begin() + p[1], p);
+        return ans;
+    }
+};
+```
 
+### **Go**
+
+```go
+func reconstructQueue(people [][]int) [][]int {
+	sort.Slice(people, func(i, j int) bool {
+		a, b := people[i], people[j]
+		return a[0] > b[0] || a[0] == b[0] && a[1] < b[1]
+	})
+	var ans [][]int
+	for _, p := range people {
+		i := p[1]
+		ans = append(ans[:i], append([][]int{p}, ans[i:]...)...)
+	}
+	return ans
+}
 ```
 
 ### **...**

solution/0400-0499/0406.Queue Reconstruction by Height/README_EN.md

@@ -41,21 +41,69 @@ Hence [[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]] is the reconstructed queue.
 	<li>It is guaranteed that the queue can be reconstructed.</li>
 </ul>
 
-
 ## Solutions
 
 <!-- tabs:start -->
 
 ### **Python3**
 
 ```python
-
+class Solution:
+    def reconstructQueue(self, people: List[List[int]]) -> List[List[int]]:
+        people.sort(key=lambda x: (-x[0], x[1]))
+        ans = []
+        for p in people:
+            ans.insert(p[1], p)
+        return ans
 ```
 
 ### **Java**
 
 ```java
+class Solution {
+    public int[][] reconstructQueue(int[][] people) {
+        Arrays.sort(people, (a, b) -> a[0] == b[0] ? a[1] - b[1] : b[0] - a[0]);
+        List<int[]> ans = new ArrayList<>(people.length);
+        for (int[] p : people) {
+            ans.add(p[1], p);
+        }
+        return ans.toArray(new int[ans.size()][]);
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {
+        sort(people.begin(), people.end(), [](const vector<int>& a, const vector<int>& b) {
+            return a[0] > b[0] || (a[0] == b[0] && a[1] < b[1]);
+        });
+        vector<vector<int>> ans;
+        for (const vector<int>& p: people)
+            ans.insert(ans.begin() + p[1], p);
+        return ans;
+    }
+};
+```
 
+### **Go**
+
+```go
+func reconstructQueue(people [][]int) [][]int {
+	sort.Slice(people, func(i, j int) bool {
+		a, b := people[i], people[j]
+		return a[0] > b[0] || a[0] == b[0] && a[1] < b[1]
+	})
+	var ans [][]int
+	for _, p := range people {
+		i := p[1]
+		ans = append(ans[:i], append([][]int{p}, ans[i:]...)...)
+	}
+	return ans
+}
 ```
 
 ### **...**

solution/0400-0499/0406.Queue Reconstruction by Height/Solution.cpp

@@ -0,0 +1,12 @@
+class Solution {
+public:
+    vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {
+        sort(people.begin(), people.end(), [](const vector<int>& a, const vector<int>& b) {
+            return a[0] > b[0] || (a[0] == b[0] && a[1] < b[1]);
+        });
+        vector<vector<int>> ans;
+        for (const vector<int>& p: people)
+            ans.insert(ans.begin() + p[1], p);
+        return ans;
+    }
+};

solution/0400-0499/0406.Queue Reconstruction by Height/Solution.go

@@ -0,0 +1,12 @@
+func reconstructQueue(people [][]int) [][]int {
+	sort.Slice(people, func(i, j int) bool {
+		a, b := people[i], people[j]
+		return a[0] > b[0] || a[0] == b[0] && a[1] < b[1]
+	})
+	var ans [][]int
+	for _, p := range people {
+		i := p[1]
+		ans = append(ans[:i], append([][]int{p}, ans[i:]...)...)
+	}
+	return ans
+}

solution/0400-0499/0406.Queue Reconstruction by Height/Solution.java

@@ -1,10 +1,10 @@
 class Solution {
     public int[][] reconstructQueue(int[][] people) {
-        Arrays.sort(people, (o1, o2) -> o1[0] != o2[0] ? Integer.compare(o2[0], o1[0]) : Integer.compare(o1[1], o2[1]));
-        List<int[]> res = new ArrayList<>(people.length);
+        Arrays.sort(people, (a, b) -> a[0] == b[0] ? a[1] - b[1] : b[0] - a[0]);
+        List<int[]> ans = new ArrayList<>(people.length);
         for (int[] p : people) {
-            res.add(p[1], p);
+            ans.add(p[1], p);
         }
-        return res.toArray(new int[res.size()][]);
+        return ans.toArray(new int[ans.size()][]);
     }
-}
+}

solution/0400-0499/0406.Queue Reconstruction by Height/Solution.py

@@ -0,0 +1,7 @@
+class Solution:
+    def reconstructQueue(self, people: List[List[int]]) -> List[List[int]]:
+        people.sort(key=lambda x: (-x[0], x[1]))
+        ans = []
+        for p in people:
+            ans.insert(p[1], p)
+        return ans