Given an array `nums` of distinct integers, return all the possible permutations. You can return the answer in any order.

Example 1:

```Input: nums = [1,2,3]
Output: [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
```

Example 2:

```Input: nums = [0,1]
Output: [[0,1],[1,0]]
```

Example 3:

```Input: nums = [1]
Output: [[1]]
```

Constraints:

• `1 <= nums.length <= 6`
• `-10 <= nums[i] <= 10`
• All the integers of `nums` are unique.

Idea:

Use DFS template

Solution:

``````/**
* @param {number[]} nums
* @return {number[][]}
*/
var permute = function(nums) {
let res = [];
let cur = [];
let len = nums.length;
let used = new Array(len).fill(false);
dfs(nums, len, res, cur, used);
return res;
}

function dfs(nums, len, res, cur, used) {
// exit recursive condition
if (cur.length === len) {
res.push(cur.concat());
return;
}

// possible solution
for (let i = 0; i < len; i++) {
// skip used integer
if (used[i]) continue;

// modify current state
used[i] = true;
cur.push(nums[i]);
dfs(nums, len, res, cur, used);
// recover current state
cur.pop();
used[i] = false;
}
}``````