Skip to content

Commit 19b8a93

Browse files
YangFongYangFong
committed
feat: add solutions to lc problems: No.0046,0047
- No.0046.Permutations - No.0047.Permutations II
1 parent 6cefe38 commit 19b8a93

File tree

8 files changed

+376
-60
lines changed

8 files changed

+376
-60
lines changed

‎solution/0000-0099/0046.Permutations/README.md

+55-20
Original file line numberDiff line numberDiff line change
@@ -176,6 +176,42 @@ public:
176176
};
177177
```
178178

179+
### **C#**
180+
181+
```cs
182+
using System.Collections.Generic;
183+
using System.Linq;
184+
185+
public class Solution {
186+
public IList<IList<int>> Permute(int[] nums) {
187+
var results = new List<IList<int>>();
188+
var temp = new List<int>();
189+
var visited = new bool[nums.Length];
190+
Search(nums, visited, temp, results);
191+
return results;
192+
}
193+
194+
private void Search(int[] nums, bool[] visited, IList<int> temp, IList<IList<int>> results)
195+
{
196+
int count = 0;
197+
for (var i = 0; i < nums.Length; ++i)
198+
{
199+
if (visited[i]) continue;
200+
++count;
201+
temp.Add(nums[i]);
202+
visited[i] = true;
203+
Search(nums, visited, temp, results);
204+
temp.RemoveAt(temp.Count - 1);
205+
visited[i] = false;
206+
}
207+
if (count == 0 && temp.Any())
208+
{
209+
results.Add(new List<int>(temp));
210+
}
211+
}
212+
}
213+
```
214+
179215
### **Go**
180216

181217
```go
@@ -210,19 +246,19 @@ func dfs(u, n int, nums []int, used []bool, path []int, res *[][]int) {
210246

211247
```ts
212248
function permute(nums: number[]): number[][] {
249+
const n = nums.length;
213250
const res: number[][] = [];
214-
const dfs = (paths: number[]) => {
215-
if (paths.length === nums.length) {
216-
res.push(paths);
217-
return;
251+
const dfs = (i: number) => {
252+
if (i === n) {
253+
res.push([...nums]);
218254
}
219-
for (const num of nums) {
220-
if (!paths.includes(num)) {
221-
dfs(paths.concat(num));
222-
}
255+
for (let j = i; j < n; j++) {
256+
[nums[i], nums[j]] = [nums[j], nums[i]];
257+
dfs(i + 1);
258+
[nums[i], nums[j]] = [nums[j], nums[i]];
223259
}
224260
};
225-
dfs([]);
261+
dfs(0);
226262
return res;
227263
}
228264
```
@@ -231,23 +267,22 @@ function permute(nums: number[]): number[][] {
231267

232268
```rust
233269
impl Solution {
234-
fn dfs(nums: &Vec<i32>, paths: &mut Vec<i32>, res: &mut Vec<Vec<i32>>) {
235-
if paths.len() == nums.len() {
236-
res.push(paths.clone());
270+
fn dfs(i: usize, nums: &mut Vec<i32>, res: &mut Vec<Vec<i32>>) {
271+
let n = nums.len();
272+
if i == n {
273+
res.push(nums.clone());
237274
return;
238275
}
239-
for i in nums.iter() {
240-
if !paths.contains(i) {
241-
paths.push(*i);
242-
Self::dfs(nums, paths, res);
243-
paths.pop();
244-
}
276+
for j in i..n {
277+
nums.swap(i, j);
278+
Self::dfs(i + 1, nums, res);
279+
nums.swap(i, j);
245280
}
246281
}
247282

248-
pub fn permute(nums: Vec<i32>) -> Vec<Vec<i32>> {
283+
pub fn permute(mut nums: Vec<i32>) -> Vec<Vec<i32>> {
249284
let mut res = vec![];
250-
Self::dfs(&nums, &mut vec![], &mut res);
285+
Self::dfs(0, &mut nums, &mut res);
251286
res
252287
}
253288
}

‎solution/0000-0099/0046.Permutations/README_EN.md

+55-20
Original file line numberDiff line numberDiff line change
@@ -155,6 +155,42 @@ public:
155155
};
156156
```
157157

158+
### **C#**
159+
160+
```cs
161+
using System.Collections.Generic;
162+
using System.Linq;
163+
164+
public class Solution {
165+
public IList<IList<int>> Permute(int[] nums) {
166+
var results = new List<IList<int>>();
167+
var temp = new List<int>();
168+
var visited = new bool[nums.Length];
169+
Search(nums, visited, temp, results);
170+
return results;
171+
}
172+
173+
private void Search(int[] nums, bool[] visited, IList<int> temp, IList<IList<int>> results)
174+
{
175+
int count = 0;
176+
for (var i = 0; i < nums.Length; ++i)
177+
{
178+
if (visited[i]) continue;
179+
++count;
180+
temp.Add(nums[i]);
181+
visited[i] = true;
182+
Search(nums, visited, temp, results);
183+
temp.RemoveAt(temp.Count - 1);
184+
visited[i] = false;
185+
}
186+
if (count == 0 && temp.Any())
187+
{
188+
results.Add(new List<int>(temp));
189+
}
190+
}
191+
}
192+
```
193+
158194
### **Go**
159195

160196
```go
@@ -189,19 +225,19 @@ func dfs(u, n int, nums []int, used []bool, path []int, res *[][]int) {
189225

190226
```ts
191227
function permute(nums: number[]): number[][] {
228+
const n = nums.length;
192229
const res: number[][] = [];
193-
const dfs = (paths: number[]) => {
194-
if (paths.length === nums.length) {
195-
res.push(paths);
196-
return;
230+
const dfs = (i: number) => {
231+
if (i === n) {
232+
res.push([...nums]);
197233
}
198-
for (const num of nums) {
199-
if (!paths.includes(num)) {
200-
dfs(paths.concat(num));
201-
}
234+
for (let j = i; j < n; j++) {
235+
[nums[i], nums[j]] = [nums[j], nums[i]];
236+
dfs(i + 1);
237+
[nums[i], nums[j]] = [nums[j], nums[i]];
202238
}
203239
};
204-
dfs([]);
240+
dfs(0);
205241
return res;
206242
}
207243
```
@@ -210,23 +246,22 @@ function permute(nums: number[]): number[][] {
210246

211247
```rust
212248
impl Solution {
213-
fn dfs(nums: &Vec<i32>, paths: &mut Vec<i32>, res: &mut Vec<Vec<i32>>) {
214-
if paths.len() == nums.len() {
215-
res.push(paths.clone());
249+
fn dfs(i: usize, nums: &mut Vec<i32>, res: &mut Vec<Vec<i32>>) {
250+
let n = nums.len();
251+
if i == n {
252+
res.push(nums.clone());
216253
return;
217254
}
218-
for i in nums.iter() {
219-
if !paths.contains(i) {
220-
paths.push(*i);
221-
Self::dfs(nums, paths, res);
222-
paths.pop();
223-
}
255+
for j in i..n {
256+
nums.swap(i, j);
257+
Self::dfs(i + 1, nums, res);
258+
nums.swap(i, j);
224259
}
225260
}
226261

227-
pub fn permute(nums: Vec<i32>) -> Vec<Vec<i32>> {
262+
pub fn permute(mut nums: Vec<i32>) -> Vec<Vec<i32>> {
228263
let mut res = vec![];
229-
Self::dfs(&nums, &mut vec![], &mut res);
264+
Self::dfs(0, &mut nums, &mut res);
230265
res
231266
}
232267
}

‎solution/0000-0099/0046.Permutations/Solution.rs

+10-11
Original file line numberDiff line numberDiff line change
@@ -1,21 +1,20 @@
11
impl Solution {
2-
fn dfs(nums: &Vec<i32>, paths: &mut Vec<i32>, res: &mut Vec<Vec<i32>>) {
3-
if paths.len() == nums.len() {
4-
res.push(paths.clone());
2+
fn dfs(i: usize, nums: &mut Vec<i32>, res: &mut Vec<Vec<i32>>) {
3+
let n = nums.len();
4+
if i == n {
5+
res.push(nums.clone());
56
return;
67
}
7-
for i in nums.iter() {
8-
if !paths.contains(i) {
9-
paths.push(*i);
10-
Self::dfs(nums, paths, res);
11-
paths.pop();
12-
}
8+
for j in i..n {
9+
nums.swap(i, j);
10+
Self::dfs(i + 1, nums, res);
11+
nums.swap(i, j);
1312
}
1413
}
1514

16-
pub fn permute(nums: Vec<i32>) -> Vec<Vec<i32>> {
15+
pub fn permute(mut nums: Vec<i32>) -> Vec<Vec<i32>> {
1716
let mut res = vec![];
18-
Self::dfs(&nums, &mut vec![], &mut res);
17+
Self::dfs(0, &mut nums, &mut res);
1918
res
2019
}
2120
}

‎solution/0000-0099/0046.Permutations/Solution.ts

+9-9
Original file line numberDiff line numberDiff line change
@@ -1,16 +1,16 @@
11
function permute(nums: number[]): number[][] {
2+
const n = nums.length;
23
const res: number[][] = [];
3-
const dfs = (paths: number[]) => {
4-
if (paths.length === nums.length) {
5-
res.push(paths);
6-
return;
4+
const dfs = (i: number) => {
5+
if (i === n) {
6+
res.push([...nums]);
77
}
8-
for (const num of nums) {
9-
if (!paths.includes(num)) {
10-
dfs(paths.concat(num));
11-
}
8+
for (let j = i; j < n; j++) {
9+
[nums[i], nums[j]] = [nums[j], nums[i]];
10+
dfs(i + 1);
11+
[nums[i], nums[j]] = [nums[j], nums[i]];
1212
}
1313
};
14-
dfs([]);
14+
dfs(0);
1515
return res;
1616
}

‎solution/0000-0099/0047.Permutations II/README.md

+100
Original file line numberDiff line numberDiff line change
@@ -141,6 +141,49 @@ public:
141141
};
142142
```
143143

144+
### **C#**
145+
146+
```cs
147+
using System.Collections.Generic;
148+
using System.Linq;
149+
150+
public class Solution {
151+
public IList<IList<int>> PermuteUnique(int[] nums) {
152+
var results = new List<IList<int>>();
153+
var temp = new List<int>();
154+
var count = nums.GroupBy(n => n).ToDictionary(g => g.Key, g => g.Count());
155+
Search(count, temp, results);
156+
return results;
157+
}
158+
159+
private void Search(Dictionary<int, int> count, IList<int> temp, IList<IList<int>> results)
160+
{
161+
if (!count.Any() && temp.Any())
162+
{
163+
results.Add(new List<int>(temp));
164+
return;
165+
}
166+
var keys = count.Keys.ToList();
167+
foreach (var key in keys)
168+
{
169+
temp.Add(key);
170+
--count[key];
171+
if (count[key] == 0) count.Remove(key);
172+
Search(count, temp, results);
173+
temp.RemoveAt(temp.Count - 1);
174+
if (count.ContainsKey(key))
175+
{
176+
++count[key];
177+
}
178+
else
179+
{
180+
count[key] = 1;
181+
}
182+
}
183+
}
184+
}
185+
```
186+
144187
### **Go**
145188

146189
```go
@@ -173,6 +216,63 @@ func dfs(u, n int, nums []int, used []bool, path []int, res *[][]int) {
173216
}
174217
```
175218

219+
### **TypeScript**
220+
221+
```ts
222+
function permuteUnique(nums: number[]): number[][] {
223+
const n = nums.length;
224+
const res: number[][] = [];
225+
const dfs = (i: number) => {
226+
if (i === n) {
227+
res.push([...nums]);
228+
}
229+
const set = new Set<number>();
230+
for (let j = i; j < n; j++) {
231+
if (set.has(nums[j])) {
232+
continue;
233+
}
234+
set.add(nums[j]);
235+
[nums[i], nums[j]] = [nums[j], nums[i]];
236+
dfs(i + 1);
237+
[nums[i], nums[j]] = [nums[j], nums[i]];
238+
}
239+
};
240+
dfs(0);
241+
return res;
242+
}
243+
```
244+
245+
### **Rust**
246+
247+
```rust
248+
use std::collections::HashSet;
249+
impl Solution {
250+
fn dfs(i: usize, nums: &mut Vec<i32>, res: &mut Vec<Vec<i32>>) {
251+
let n = nums.len();
252+
if i == n {
253+
res.push(nums.clone());
254+
return;
255+
}
256+
let mut set = HashSet::new();
257+
for j in i..n {
258+
if set.contains(&nums[j]) {
259+
continue;
260+
}
261+
set.insert(nums[j]);
262+
nums.swap(i, j);
263+
Self::dfs(i + 1, nums, res);
264+
nums.swap(i, j);
265+
}
266+
}
267+
268+
pub fn permute_unique(mut nums: Vec<i32>) -> Vec<Vec<i32>> {
269+
let mut res = vec![];
270+
Self::dfs(0, &mut nums, &mut res);
271+
res
272+
}
273+
}
274+
```
275+
176276
### **...**
177277

178278
```

0 commit comments

Comments
 (0)