just do it

20220507, 8min，中间应隔4天，但是隔了8天才回顾

|
```javascript /**

• @param {number[]} nums

• @return {number[][]} */ // 10:51 -> 10:59 // 回溯 var permuteUnique = function(nums) { nums.sort((a, b) => a - b); // bug:忘写了 const len = nums.length; let ans = []; let path = []

  // for (let i = 0; i < len; i++) { // bug：回溯函数与循环的顺序错了 const trackBacking = (used) => { if (path.length === len) { ans.push([…path]); return; } // const trackBacking = (used) => { for (let i = 0; i < len; i++) { if (used[i]) continue; if (i > 0 && nums[i] === nums[i-1] && !used[i-1]) continue;

  path.push(nums[i]); used[i] = true; trackBacking(used); path.pop(); used[i] = false; } } trackBacking([]); return ans; }; ``` | | —- |

20220428，9min

|
```javascript /**

• @param {number[]} nums

• @return {number[][]} */ // 19:28 -> 19:37 // 回溯 var permuteUnique = function(nums) { nums.sort((a, b) => a - b); // bug：忘记写了 const path = []; const ans = []; const len = nums.length; const backtracking = (used) => { if (path.length === len) { ans.push([…path]) return; }

  for (let i = 0; i < len; i++) { if (used[i]) continue; // if (i > 0 && nums[i] === nums[i-1] && !used[i]) continue; // bug：used[i-1]为false，而不是used[i]才能退出这次循环 if (i > 0 && nums[i] === nums[i-1] && !used[i-1]) continue; path.push(nums[i]); used[i] = true; backtracking(used); path.pop(); used[i] = false; } } backtracking([]); return ans; }; ``` | | —- |

20220425, 3min

|
```javascript /**

• @param {number} capacity */ // 22:09 -> 22:12 var LRUCache = function(capacity) { this.map = new Map(); this.capacity = capacity; };

/**

• @param {number} key
• @return {number} */ LRUCache.prototype.get = function(key) { if (this.map.has(key)) { const val = this.map.get(key); this.map.delete(key); this.map.set(key, val); return val; } return -1; };

/**

• @param {number} key
• @param {number} value

• @return {void} */ LRUCache.prototype.put = function(key, value) { if (this.map.has(key)) { this.map.delete(key);

  } this.map.set(key, value);

  // if (this.map.size > capacity) { // bug if (this.map.size > this.capacity) { this.map.delete(this.map.keys().next().value) } };

/**

• Your LRUCache object will be instantiated and called as such:
• var obj = new LRUCache(capacity)
• var param_1 = obj.get(key)
• obj.put(key,value) */ ``` | | —- |

20220422，12min

|
```javascript /**

• @param {number[]} nums

• @return {number[][]} */ // 14:05 -> 14：17 // 排序， 循环，回溯 var permuteUnique = function(nums) { // 排序 nums.sort((a, b) => a - b) // bug:这步没有写 let path = []; let ans = [];

  const backtracking = (used) => { if (path.length === nums.length) { ans.push([…path]); // ans.push(path.slice()); // return ans; // bug：答案也会对 return; }

  for (let i = 0; i < nums.length; i++) { if(used[i]) continue; if(i > 0 && nums[i] === nums[i-1] && !used[i-1]) continue; path.push(nums[i]); used[i] = true; // backtracking[used]; // bug:backtracking是函数，如果写成这样，最后结果为[] backtracking(used); // path.pop(nums[i]); // bug：pop()后没有参数 path.pop(); used[i] = false; } } backtracking([]); // bug：这步忘写了 return ans; }; ``` | | —- |

20220421，8min

|
```javascript /**

• @param {number[]} nums

• @return {number[][]} */ // 15:26 -> 15：34 // 递归，树层剪枝，回溯 var permuteUnique = function(nums) { nums.sort((a, b) => a - b);

  let path = []; let result = [];

  const backtracking = (used) => { if (path.length === nums.length) { // result = […path]; // bug：值应该放到追加到结果数组中，而不是直接赋值 result.push([…path]); return; } for (let i = 0; i < nums.length; i++) { if (used[i]) continue; // if (i > 0 && nums[i] === nums[i-1] && !used[i]) continue; if (i > 0 && nums[i] === nums[i-1] && !used[i-1]) continue; path.push(nums[i]); used[i] = true; backtracking(used); path.pop(); used[i] = false; } } backtracking([]) return result; }; ``` | | —- |

20220420, 14min

|
```javascript /**

• @param {number[]} nums
• @return {number[][]} */ // 16:58 -> 17:12 var permuteUnique = function(nums) { nums.sort((a, b) => a - b); // let used = []; let result = []; let path = []; const backtracing = (used) => { console.log(‘path:’, path) if (path.length === nums.length) { // result.push(path); // bug: result、path指向同一片内存，随着path的改变，原先的push进result的值也会改变，最终得到的就是n个最后的path的值，即[[], []…] result.push(path.slice()); console.log(‘result:’, result) return; } for (let i = 0; i < nums.length; i++) { if (used[i]) continue; if (i > 0 && nums[i] === nums[i - 1] && !used[i-1]) {

   continue;

  } console.log(‘nums[i]:’, nums[i]) path.push(nums[i]); used[i] = true; backtracing(used); path.pop(); used[i] = false; } } backtracing([]); return result; }; ``` 知识点
  - result = path.slice()
  | | —- |